hgbook
view es/mq.tex @ 448:c17848cfbf75
Translated a few more MQ paragraphs
| author | Igor TAmara <igor@tamarapatino.org> |
|---|---|
| date | Fri Dec 12 07:45:58 2008 -0500 (2008-12-12) |
| parents | 93e7700c0322 |
| children | 9b3cc9f398f9 |
line source
1 \chapter{Administración de cambios con Colas de Mercurial}
2 \label{chap:mq}
4 \section{El problema de la administración de parches}
5 \label{sec:mq:patch-mgmt}
7 Un escenario frecuente: usted necesita instalar un paquete de software
8 desde las fuentes, pero encuentra un fallo que debe arreglar antes de
9 poder comenzar a usarlo. Hace sus cambios, y se olvida del paquete
10 por un tiempo, unos meses después necesita actualizar a una nueva
11 versión del paquete. Si la nueva versión del paquete todavía tiene el
12 fallo, debe extraer su arreglo del árbol de fuentes anteriores y
13 aplicarlo a la nueva versión. Una tarea tediosa en la cual es fácil
14 equivocarse.
16 Este es un caso simple del problema del ``manejo de parches''. Usted
17 tiene un árbol de fuentes del ``mantenedor principal'' que no puede
18 cambiar: necesita hacer algunos cambios locales sobre el árbol
19 principal; y desearía poder mantener tales cambios separados, de forma
20 tal que pueda aplicarlos a versiones más nuevas del árbol principal.
22 El problema de administración de parches surge en muchas situaciones.
23 Probablemente la más visible es cuando un usuario de un proyecto de
24 software de fuentes abiertas contribuye con un arreglo de un fallo o
25 una nueva característica a los mantenedores del proyecto en la forma
26 de un parche.
28 Aquellos que distribuyen sistemas operativos que incluyen programas
29 abiertos usualmente requieren hacer cambios en los paquetes que
30 distribuyen de tal forma que se armen apropiadamente en sus ambientes.
32 Cuando hay pocos cambios por mantener, es muy sencillo administrar un
33 solo parche con los programas estándar \command{diff} y
34 \command{patch}( ver la sección~\ref{sec:mq:patch} para ver cómo
35 emplear tales herramientas). Cuando la cantidad de cambios comienza a
36 crecer, tiene sentido mantener parches como ``porciones de trabajo''
37 individual, de forma que cada cambio contiene solamente un arreglo de
38 un fallo(el parche puede modificar varios archivos, pero está
39 ``haciendo una sola cosa''), y puede tener cierta cantidad de tales
40 parches para diferentes fallos y cambios locales. En esta situación,
41 si envía un parche que arregla un fallo a los mantenedores principales
42 de un paquete y ellos incluyen su arreglo en una publicación
43 posterior, puede deshacerse de tal parche cuando se actualice a la
44 nueva versión.
46 Mantener un solo parche frente a un árbol principal es algo tedioso y
47 es fácil equivocarse, pero no es difícil. Aunque, la complejidad del
48 problema crece rápidamente a medida que la cantidad de parches que
49 tiene que mantener crece. Con más que una pequeña cantidad de
50 cambios, entender cuáles ha aplicado se convierte de algo desordenado
51 a algo avasallante.
53 Afortunadamente Mercurial provee una extensión poderos: Colas de
54 Mercurial( o simplemente ``MQ''), que simplifica en gran medida el
55 problema de administración de parches.
57 \section{La prehistoria de las Colas de Mercurial}
58 \label{sec:mq:history}
60 A finales de los 90s, muchos desarrolladores del núcleo de Linux
61 comenzaron a mantener ``series de parches'' que modificaron el
62 comportamiento del núcleo de Linux. Algunos se enfocaban en
63 estabilidad, otros en aumentar las características, y otros un poco
64 más especulativos.
66 Los tamaños de las series de parches crecieron rápidamente. En el
67 2002, Andrew Morton publicó algunos guiones de línea de órdenes que
68 estuvo usando para automatizar la tarea de administrar su cola de
69 parches. Andrew usó exitósamente tales guiones para administrar
70 centenas( aveces millares) de parches en el núcleo de Linux.
72 \subsection{Trabajar parches con quilt}
73 \label{sec:mq:quilt}
75 A comienzos del 2003, Andreas Gruenbacher y Martin Quinson tomaron la
76 aproximación de los guiones de Andrew y publicaron una herramienta
77 llamada
78 ``patchwork quilt''~\cite{web:quilt}, o simplemente ``quilt''
79 (ver~\cite{gruenbacher:2005} el paper que lo describe). Dado que
80 quilt automatizaba sustancialmente la administración de parches, fue
81 adoptado en gran medida por desarrolladores de programas abiertos.
83 Quilt maneja una \emph{pila de parches} sobre un árbol de directorios.
84 Para comenzar, usted le indica a quilt que administre un árbol de
85 directorios, le indica qué archivos manejar; Este almacena los nombres
86 y los contenidos de estos archivos. Para arreglar un fallo, usted
87 crea un nuevo parche(con una sola orden), edita los archivos que está
88 arreglando y ``refresca'' el parche.
90 El paso de refresco hace que quilt revise el árbol de directorios;
91 actualiza el parche con todos los cambios que usted haya hecho. Puede
92 crear otro parche sobre el primero, que hará seguimiento de los
93 cambios requeridos para modificar el árbol desde ``el árbol con un
94 parch aplicado'' a un ``árbol con dos parches aplicados''.
96 Usted puede \emph{elegir} qué cambios desea aplicar al árbol. Si
97 ``pop''\ndt{saca} un parche, los cambios hechos por tal parchve
98 desapareceŕan del árbol de directorios. Quilt recuerda qué parches ha
99 sacado, para que pueda ``introducirlos''\ndt{push} posteriormente, así el
100 árbol de directorios se restaurará con las modificaciones que vienen
101 del parche. Lo más importante es que puede ejecutar la orden
102 ``refresh'' en cualquier momento, y el último parche será
103 actualizado. Esto significa que puede, en cualquier momento, cambiar
104 qué parches serán aplicados y qué modificaciones hacen ellos.
106 Quilt no tiene nada que ver con herramientas de control de versiones,
107 y puede trabajar bien sobre un conjunto de fuentes que viene de un
108 archivo comprimido y empaquetado o una copia de trabajo de Subversion.
110 \subsection{Pasar de trabajo con parches con Quilt hacia Colas de Mercurial}
111 \label{sec:mq:quilt-mq}
113 A mediados de 2005, Chris Mason tomó las características de quilt y
114 escribió una extensión que llamó Colas de Mercurial\ndt{Mercurial
115 Queues}, que proporcionó un comportamiento a Mercurial al estilo
116 quilt.
118 La diferencia clave entre quilt y MQ es que quilt no sabe nada acerca
119 del sistema de control de revisiones, mientras que MQ está
120 \emph{integrado} con Mercurial. Cada parche que usted introduce se
121 representa como un conjunto de cambios en Mercurial. Si sustrae un
122 parche, el conjunto de cambios desaparece.\ndt{introduce originalmente es
123 push y pop es sustraer en este contexto, usaremos el original en inglés
124 cuando encontremos que facilita la comprensión}
126 Dado que quilt no se preocupa por las herramientas de control de
127 revisiones, continúa siendo una porción de software tremendamente útil
128 para aquellas situaciones en las cuales no puede usar Mercurial y MQ.
130 \section{La gran ventaja de MQ}
132 No puedo sobreestimar el valor que MQ ofrece en la unificación de
133 parches y el control de revisiones.
135 La principal razón por la cual los parches han persistido en el mundo
136 del software libre y de fuentes abiertas--a pesar de la creciente
137 disponibilidad de herramientas poderosas de control de revisiones-- es
138 la \emph{agilidad} que ofrecen.
140 Las herramientas tradicionales de control de revisiones llevan un
141 registro permanente e irreversible de todo lo que usted hace. A pesar
142 de que esto tiene gran valor, también es bastante sutil. Si requiere
143 realizar un experimento ((((wild-eyed)))), debe ser cuidadoso en cómo
144 lo hace, o puede dejar trazas innecesarias--o peor aún,
145 desconcertantes o desestabilizantes--- de los pasos y errores en el
146 registro de revisiones de forma permanente.
148 En contraste, con la cohesión de MQ con el control de revisiones
149 distribuidos y los parches, resulta más sencillo aislar su trabajo.
150 Sus parches viven encima de la historia de revisiones normales, y
151 puede hacer que ellos desaparezcan o reaparezcan cuando lo desee. Si
152 no le gusta un parche, puede desecharlo. Si un parche no satisface
153 todo lo que usted desea, puede arreglarlo---tantas veces como lo
154 requiera, hasta que lo haya refinado lo suficiente hacia sus
155 expectativas.
157 Por ejemplo, la integración de parches con el control de revisiones
158 hace que el entender los parches y revisar sus efectos---y sus
159 interacciones con el código en el cuál están enlazados--- sea
160 \emph{mucho} más sencillo. Dado que todo parche que se aplique tiene
161 un conjunto de cambios asociado, puede usar
162 \hgcmdargs{log}{\emph{filename}} para ver qué conjuntos de cambios y
163 parches afectaron un fichero. Puede usar la orden \hgext{bisect} para
164 hacer una búsqueda binaria sobre todos los conjuntos de cambios y
165 parches aplicados para ver dónde se introdujo un fallo o dónde fue
166 arreglado. Puede usar la orden \hgcmd{annotate} para ver qué
167 conjuntos de cambios o parches modificaron una línea particular de un
168 archivo fuente. Y mucho más.
170 \section{Entender los parches}
171 \label{sec:mq:patch}
173 Dado que MQ no esconde su naturaleza parche-céntrica, es muy útil para
174 entender de qué se tratan los parches, y un poco acerca de las
175 herramientas que trabajan con ellos.
177 La orden de Unix tradicional \command{diff} compara dos ficheros, e
178 imprime una lista de diferencias de sus líneas. La orden
179 \command{patch} entiende esas diferencias como \emph{modificaciones}
180 para construir un fichero. Vea en la figura~\ref{ex:mq:diff} un
181 ejemplo sencillo de tales órdenes en acción.
183 \begin{figure}[ht]
184 \interaction{mq.dodiff.diff}
185 \caption{Uso sencillo de las órdenes \command{diff} y \command{patch}}
186 \label{ex:mq:diff}
187 \end{figure}
189 El tipo de fichero que \command{diff} genera (y que \command{patch}
190 toma como entrada) se llama un ``parche'' o un ``diff''; no hay
191 diferencia entre un parche y un diff. (Usaremos el término ``parche'',
192 dado que es el que más comunmente se usa.)
194 Un parche puede comenzar con un texto arbitrario; la orden \command{patch}
195 ignora este texto, pero MQ lo usa como el mensaje de consignación
196 cuando se crean conjuntos de cambios. Para encontrar el inicio del
197 contenido de un parche, la orden \command{patch} busca la primera
198 línea que comience con la cadena ``\texttt{diff~-}''.
200 MQ trabaja con diffs \emph{unificados} (\command{patch} acepta varios
201 formatos de diff adicionales, pero MQ no). Un diff unificado contiene
202 dos clases de encabezados. El \emph{encabezado de fichero} describe
203 el fichero que se está modificando; contiene el nombre del fichero a
204 modificar. Cuando \command{patch} ve un nuevo encabezado de fichero,
205 busca un fichero con ese nombre para modificarlo.
207 Después del encabezaado vienen varios \emph{trozos}. Cada trozo
208 comienza con un encabezado; que identifica el rango de líneas del
209 fichero que el trozo debe modificar. Después del encabezado, un trozo
210 comienza y termina con unas pocas líneas(usualmente tres) de texto del
211 fichero que no han sido modificadas; las cuales llamamos el
212 \emph{contexto} del trozo. Si solamente hay una pequeña cantidad de
213 contexto entre trozos sucesivos, \command{diff} no imprime un nuevo
214 encabezado para el trozo, continua integrando los trozos, con unas
215 líneas de contexto entre las modificaciones.
217 Cada línea de contexto comienza con un caracter de espacio. En el
218 trozo, si una línea comienza con ``\texttt{-}'' significa ``elimine
219 esta línea'', si la línea comienza con un ``\texttt{+}'' significa
220 ``inserte esta línea''. Por ejemplo, una línea que se modifica se
221 representa con una línea eliminada y una línea insertada.
223 Retomaremos aspectos más sutiles acerca de parches posteriormente(en
224 la sección~\ref{sec:mq:adv-patch}), pero en el momento usted ya
225 debería tener suficiente información para usar MQ.
227 \section{Comenzar a usar Colas de Mercurial}
228 \label{sec:mq:start}
230 Dado que MQ está implementado como una extensión, debe habilitarla
231 explícitamente antes de comenzar a usarla. (No necesita descargar
232 nada; MQ viene con la distribución estándar de Mercurial.) Para
233 habilitar MQ, edite su fichero \tildefile{.hgrc}, y añada las líneas
234 de la figura~\ref{ex:mq:config}.
236 \begin{figure}[ht]
237 \begin{codesample4}
238 [extensions]
239 hgext.mq =
240 \end{codesample4}
241 \label{ex:mq:config}
242 \caption{Líneas a añadir en \tildefile{.hgrc} para habilitar la extensión MQ}
243 \end{figure}
245 Cuando la extensión esté habilitada, aparecerán varios comandos. Para
246 verificar que la extensión está trabajando, puede usar \hgcmd{help}
247 para ver si la orden \hgxcmd{mq}{qinit} está disponible; vea un
248 ejemplo en la figura~\ref{ex:mq:enabled}.
250 \begin{figure}[ht]
251 \interaction{mq.qinit-help.help}
252 \caption{Cómo verificar que MQ está habilitado}
253 \label{ex:mq:enabled}
254 \end{figure}
256 Puede usar MQ en \emph{cualquier} repositorio de Mercurial, y sus
257 comandos solamente operarán con tal repositorio. Para comenzar, basta
258 con preparar el repositorio con la orden \hgxcmd{mq}{qinit}(ver la
259 figura~\ref{ex:mq:qinit}). Esta orden crea un directorio vacío
260 llamado \sdirname{.hg/patches}, donde MQ mantendrá sus metadatos. Como
261 otras ordenes de Mercurial, la orden \hgxcmd{mq}{qinit} no imprime
262 nada cuando es exitosa.
264 \begin{figure}[ht]
265 \interaction{mq.tutorial.qinit}
266 \caption{Preparar un repositorio para usar MQ}
267 \label{ex:mq:qinit}
268 \end{figure}
270 \begin{figure}[ht]
271 \interaction{mq.tutorial.qnew}
272 \caption{Crear un nuevo parche}
273 \label{ex:mq:qnew}
274 \end{figure}
276 \subsection{Crear un nuevo parche}
278 Para comenzar a trabajar en un nuevo parche use la orden
279 \hgxcmd{mq}{qnew}. Esta orden recibe un argumento, el nombre del
280 parche a crear. MQ lo usará como el nombre del fichero en el
281 directorio \sdirname{.hg/patches}, como puede apreciarlo en la
282 figura~\ref{ex:mq:qnew}.
284 También hay otros dos nuevos ficheros en el directorio
285 \sdirname{.hg/patches}: \sfilename{series} y \sfilename{status}. El
286 fichero \sfilename{series} lista todos los parches de los cuales MQ
287 tiene noticia para este repositorio, con un parche por línea.
288 Mercurial usa el fichero \sfilename{status} para mantener registros
289 interns; da seguimiento a todos los parches que MQ ha \emph{aplicado}
290 en el repositorio.
292 \begin{note}
293 En ciertas ocasiones usted querrá editar el fichero
294 \sfilename{series} a mano; por ejemplo, cambiar el orden en que se
295 aplican ciertos parches. A pesar de esto, es una mala idea editar
296 manualmente el fichero \sfilename{status}, dado que es fácil
297 desorientar a MQ acerca de lo que está pasando.
298 \end{note}
300 Una vez que haya creado un nuevo parche, puede editar los ficheros en
301 el directorio de trabajo, como lo haría usualmente. Toda las órdenes
302 que de a Mercurial, tales como \hgcmd{diff} y \hgcmd{annotate},
303 trabajarán de la misma forma como lo han hecho antes.
305 \subsection{Refrescar un parche}
307 Cuando usted llega a un punto en el cual desea guardar su trabajo, use
308 la orden \hgxcmd{mq}{qrefresh}(figura~\ref{ex:mq:qnew}) para
309 actualizar el parche en el cual está trabajando. Esta orden almacena
310 los cambios que haya hecho al directorio actual de trabajo en su
311 parche, y almacena el conjunto de cambios correspondiente que contiene
312 los cambios.
314 \begin{figure}[ht]
315 \interaction{mq.tutorial.qrefresh}
316 \caption{Refrescar un parche}
317 \label{ex:mq:qrefresh}
318 \end{figure}
320 Puede ejecutar la orden \hgxcmd{mq}{qrefresh} tan seguido como quiera,
321 y es una buena forma de ``colocar marcas'' a su trabajo. Refresque su
322 parche en momentos oportunos; intente un experimento; si el
323 experimento no funciona, Use \hgcmd{revert} sobre sus modificaciones
324 para volver al refresco anterior.
326 \begin{figure}[ht]
327 \interaction{mq.tutorial.qrefresh2}
328 \caption{Refrescar un parche muchas veces para acumular cambios}
329 \label{ex:mq:qrefresh2}
330 \end{figure}
332 \subsection{Aplicar un parche tras otro y dar seguimiento}
334 Cuando haya terminado de trabajar en un parche, o necesite trabajar en
335 otro, puede usar la orden \hgxcmd{mq}{qnew} para crear un nuevo
336 parche. Mercurial aplicará este parche sobre su parche anterior.
337 Para un ejemplo, ver la figura~\ref{ex:mq:qnew2}. Note que el parche
338 contiene los cambios en nuestro parche anterior como parte de su
339 contexto( lo verá más claramente en la salida de \hgcmd{annotate}).
341 \begin{figure}[ht]
342 \interaction{mq.tutorial.qnew2}
343 \caption{Aplicar un parche después del primero}
344 \label{ex:mq:qnew2}
345 \end{figure}
347 Hasta ahora, con excepción de \hgxcmd{mq}{qnew} y
348 \hgxcmd{mq}{qrefresh}, hemos sido cuidadosos para aplicar únicamente
349 órdenes usuaales de Mercurial. De todas maneras, MQ ofrece muchos
350 comandos que son más sencillos de usar cuando esté pensando acerca de
351 parches, como se puede ver en la figura~\ref{ex:mq:qseries}:
353 \begin{itemize}
354 \item La orden \hgxcmd{mq}{qseries} lista cada parche del cual MQ
355 tiene noticia en este repositorio, desde el más antiguo hasta el más
356 nuevo(El último \emph{creado}).
357 \item La orden \hgxcmd{mq}{qapplied} lista cada parche que MQ haya
358 \emph{aplicado} en este repositorio, de nuevo, desde el más antiguo
359 hasta el más nuevo (El aplicado más recientemente).
360 \end{itemize}
362 \begin{figure}[ht]
363 \interaction{mq.tutorial.qseries}
364 \caption{Entender la pila de parches con \hgxcmd{mq}{qseries} y
365 \hgxcmd{mq}{qapplied}}
366 \label{ex:mq:qseries}
367 \end{figure}
369 \subsection{Manipular la pila de parches}
371 La discusión previa indicó que debe haber una diferencia entre los
372 parches ``conocidos'' y ``aplicados'', y efectivamente la hay. MQ
373 puede manejar un parche sin que este haya sido aplicado al
374 repositorio.
376 Un parche \emph{aplicado} tiene su correspondiente conjunto de cambios
377 en el repositorio, y los efectos del parche y el conjunto de cambios
378 son visibles en el directorio de trabajo. Puede deshacer la
379 aplicación de un parche con la orden \hgxcmd{mq}{qpop}. MQ
380 \emph{sabe acerca de}, o maneja un parche sustraído, pero el parche ya
381 no tendrá un conjunto de cambios correspondientes en el repositorio, y
382 el directorio de trabajo no contendrá los cambios hechos por el
383 parche. La figura~\ref{fig:mq:stack} ilustra la diferencia entre
384 parches aplicados y seguidos.
386 \begin{figure}[ht]
387 \centering
388 \grafix{mq-stack}
389 \caption{Parches aplicados y no aplicados en la pila de parches de MQ}
390 \label{fig:mq:stack}
391 \end{figure}
393 Puede reaplicar un parche no aplicado o sustraído con la orden
394 \hgxcmd{mq}{qpush}. Esto crea un nuevo conjunto de cambios
395 correspondiente al parche, y los cambios del parche estarán presentes
396 de nuevo en el directorio de trabajo. Vea ejemplos de
397 \hgxcmd{mq}{qpop} y \hgxcmd{mq}{qpush} en acción en la
398 figura~\ref{ex:mq:qpop}. Vea que hemos sustraído uno o dos parches,
399 la salida de\hgxcmd{mq}{qseries} continúa igual, mientras que
400 \hgxcmd{mq}{qapplied} ha cambiado.
402 \begin{figure}[ht]
403 \interaction{mq.tutorial.qpop}
404 \caption{Modificar la pila de parches aplicados}
405 \label{ex:mq:qpop}
406 \end{figure}
408 \subsection{Introducir y sustraer muchos parches}
410 Mientras que \hgxcmd{mq}{qpush} y \hgxcmd{mq}{qpop} operan sobre un
411 único parche cada vez, puede introducir y sustraer varios parches de
412 una vez. La opción \hgxopt{mq}{qpush}{-a} de \hgxcmd{mq}{qpush}
413 introduce todos los cambios que no hayan sido aplicados, mientras que
414 la opción \hgxopt{mq}{qpop}{-a} de \hgxcmd{mq}{qpop} sustrae todos los
415 cambios aplicados. (Vea la sección~\ref{sec:mq:perf} más adelante
416 en la cual se explican otras formas de de introducir y sustraer varios
417 cambios.)
419 \begin{figure}[ht]
420 \interaction{mq.tutorial.qpush-a}
421 \caption{Pushing all unapplied patches}
422 \label{ex:mq:qpush-a}
423 \end{figure}
425 \subsection{Medidas de seguridad y cómo saltarlas}
427 Muchas órdenes MQ revisan el directorio de trabajo antes de hacer
428 cualquier cosa, y fallan si encuentran alguna modificación. Lo hacen
429 para garantizar que usted no pierda cambio alguno de los que haya
430 hecho, pero que no hayan sido incorporados en algún parche. La
431 figura~\ref{ex:mq:add} ilusta esto; la orden \hgxcmd{mq}{qnew} no
432 creará un nuevo parche si hay cambios notorios, causados en este caso
433 por aplicado la orden \hgcmd{add} a \filename{file3}.
435 \begin{figure}[ht]
436 \interaction{mq.tutorial.add}
437 \caption{Crear un parche a la fuerza}
438 \label{ex:mq:add}
439 \end{figure}
441 Las órdenes que revisan el directorio actual cuentan con una opción
442 ``Se lo que estoy haciendo'', que siempre está nombrada como
443 \option{-f}. El significado exacto de \option{-f} depende de la
444 orden. Por ejemplo, \hgcmdargs{qnew}{\hgxopt{mq}{qnew}{-f}}
445 incorporarán cualquier cambio notorio en el nuevo parche que crea pero
446 \hgcmdargs{qpop}{\hgxopt{mq}{qpop}{-f}} revertirá las modificaciones a
447 cualquier fichero que haya sido afectado por el parche que está siendo
448 sustraído. ¡Asegúrese de leer la documentación de la opción \option{-f}
449 de cada comando antes de usarla!
451 \subsection{Trabajar con varios parches a la vez}
453 La orden \hgxcmd{mq}{qrefresh} siempre refresca el \emph{último}
454 parche aplicado. Esto significa que usted puede suspender su trabajo
455 en un parche (refrescándolo), sustraerlo o introducirlo para lograr
456 que otro parche esté de último y trabajar en \emph{ese} parche por un
457 rato.
459 A continuación un ejemplo que ilustra cómo puede usar esta habilidad.
460 Digamos que está desarrollando una nueva característica en dos
461 parches. El primero es un cambio en la parte fundamental de su
462 programa, y el segundo--sobre el primero---cambia la interfaz de
463 usuario para usar el código que ha añadido a la parte fundamental. Si
464 ve que hay un fallo en la parte fundamental mientras está trabajando
465 en el parche de UI\ndt{Interfaz de Usuario, User Interface en inglés}, es fácil arreglar la parte fundamental.
466 Simplemente use \hgxcmd{mq}{qrefresh} sobre el parche de la UI para
467 guardar los cambios de su trabajo en progreso, y use \hgxcmd{mq}{qpop}
468 para sacar sustraer el parche de la parte fundamental. Arregla el
469 fallo sobre la parte fundamental, aplique \hgxcmd{mq}{qrefresh} sobre
470 el parche fundamental, y aplique \hgxcmd{mq}{qpush} sobre el parche de
471 UI para continuar donde había quedado.
473 \section{Más acerca de parches}
474 \label{sec:mq:adv-patch}
476 MQ usa la orden GNU \command{patch} para aplicar los parches, por lo
477 tanto es útil conocer ciertos detalles de cómo trabaja
478 \command{patch}, y también acerca de los parches.
480 \subsection{La cantidad de franjas}
482 Si ve el encabezado de un parche, notará que la ruta al archivo tiene
483 un componente adicional al principio, que no está presente en la
484 ruta. Esta es una traza de cómo generaba anteriormente los parches la
485 gente(algunos aún lo hacen, pero es raro con las herramientas de
486 control de revisiones del actuales).
488 Alicia desempaquetaría un comprimido, editaría sus archivos, y querría
489 crear un parche. Por lo tanto ella renombraría su directorio de
490 trabajo, desempacaría el comprimido de nuevo(para lo cual necesitó el
491 renombramiento), y usaría las opciones \cmdopt{diff}{-r} y
492 \cmdopt{diff}{-N} de \command{diff} para generar recursivamente un
493 parche entre el directorio original y el modificado. El resultado
494 sería que el nombre del directorio original estaría al principio de
495 toda ruta en cada encabezado de fichero, y el nombre del directorio
496 modificado estaría al frente de la porción derecha de la ruta del
497 archivo.
499 Como alguien que reciba un parche de Alicia en la red podría obtener
500 dos directorios, uno original y el otro modificado con exactamente los
501 mismos nombres, la orden \command{patch} tiene la opción
502 \cmdopt{patch}{-p} que indica la cantidad de componentes de la ruta
503 a eliminar cuando se vaya a aplicar el parche. Este número se
504 llama la \emph{cantidad de eliminaciones}.
506 La opción con ``\texttt{-p1}'' significa ``elimine uno''. Si
507 \command{patch} ve un nombre de fichero \filename{foo/bar/baz} en el
508 encabezado del fichero, eliminará \filename{foo} y tratará de parchar
509 un fichero llamado \filename{bar/baz}. (Hablando estrictamente, la
510 cantidad de eliminaciones se refiere a la cantidad de \emph{separadores de
511 ruta} (y los componentes que vayan con ellos) a eliminar. Si el
512 contador es uno volverá \filename{foo/bar} en \filename{bar}, pero
513 \filename{/foo/bar} (note la barra extra) en \filename{foo/bar}.)
515 La cantidad a eliminar``estándar'' para parches es uno; casi todos los
516 parches contienen un componente inicial de la ruta que necesita ser
517 eliminado. La orden \hgcmd{diff} de Mercurial genera nombres de ruta
518 de esta forma, y la orden \hgcmd{import} y MQ esperan parches que
519 tengan a uno como cuenta de eliminaciones.
521 Si recibe un parche de alguien de quien desea adicionar adicionar a su
522 cola de parches, y el parche necesita una cuenta de eliminación que no
523 sea uno, no podrá aplicar \hgxcmd{mq}{qimport} en primera medida,
524 porque \hgxcmd{mq}{qimport} no tiene todavía una opción \texttt{-p}
525 option (ver~\bug{311}). Lo mejor que puede hacer es aplicar
526 \hgxcmd{mq}{qnew} por su cuenta, y después usar \cmdargs{patch}{-p\emph{N}}
527 para aplicar tal parche, seguido de \hgcmd{addremove} para tener en
528 cuenta cualquier fichero adicionado o eliminado por el parche, seguido
529 de \hgxcmd{mq}{qrefresh}. Esta complejidad puede ser innecesaria;
530 consulte~\bug{311} para más información.
532 \subsection{Estrategias para aplicar parches}
534 Cuando \command{patch} aplica un trozo, intenta varias estrategias
535 sucesivas que decrecen en precisión para intentar aplicarlo. Esta
536 técnica de pruebas y error aveces permite que un parche que fue
537 generado contra una versión anterior de un fichero, sea aplicada sobre
538 una versión más nueva del mismo.
540 Primero \command{patch} intenta una correspondencia perfecta donde los
541 números de línea, el contexto y el texto a modificar deben coincidir
542 perfectamente. Si no lo logra, intenta encontrar una correspondencia
543 exacta del contexto, sin tener en cuenta el número de línea. Si es
544 exitoso, imprime una línea indicando que el trozo fue aplicado, pero a
545 un \emph{corrimiento} del número de línea original.
547 Si falla la correspondencia por contexto, \command{patch} elimina la
548 primera y la última línea del contexto, e intenta una correspondencia
549 \emph{reducida} del contexto. Si el trozo con contexto reducido es
550 exitoso, imprime un mensaje indicando que aplicó el trozo con un
551 \emph{factor difuso} (el número después del factor difuso indica
552 cuántas líneas de contexto \command{patch} tuvo que eliminar antes de
553 aplicar el parche).
555 Cuando ninguna de estas técnicas funciona, \command{patch} imprime un
556 mensaje indicando que el trozo en cuestión se desechó. Almacena los
557 trozos desechados(también llamados ``descartados'') en un fichero con
558 el mismo nombre, y la extensión \sfilename{.rej} añadida. También
559 almacena una copia igual al fichero original con la extensión
560 \sfilename{.orig}; la copia del fichero sin extensión contendrá
561 cualquier cambio hecho por los trozos que \emph{sí} se aplicaron sin
562 problema. Si usted tiene un parche que modifica \filename{foo} con
563 seis trozos, y uno de ellos falla al aplicarse, tendrá : un fichero
564 original \filename{foo.orig}, un fichero \filename{foo.rej} que
565 contiene el trozo, y \filename{foo}, que contiene los cambios que se
566 aplicaron por los cinco trozos exitosos.
568 \subsection{Algunos detalles de la representación de parches}
570 Hay ciertas cosas útiles por saber acerca de cómo trabaja
571 \command{patch} con los ficheros:
572 \begin{itemize}
573 \item Debería ser obvio que \command{patch} no puede manipular
574 ficheros binarios.
575 \item No se preocupa por el bit ejecutable; crea ficheros nuevos en
576 modo lectura, pero no ejecutable.
577 \item \command{patch} intenta eliminar un fichero como una diferencia
578 entre el fichero a eliminar y un fichero vacío. Y por lo tanto su
579 idea de ``Borré este fichero'' debería pensarse como ``toda línea de
580 este fichero fue eliminada'' en un parche.
581 \item Trata la adición de un fichero como un diff entre un fichero
582 vacío y el fichero a ser adicionado. Por lo tanto en un parche su
583 idea de ``Añadí este fichero'' se vería como ``toda línea de este
584 fichero fue añadida''.
585 \item Trata el renombramiento de un fichero como la eliminación del
586 nombre anterior y la adición del nuevo nombre. Esto significa que
587 los ficheros renombrados dejan un rastro grande en los parches.
588 (Tenga en cuenta que Mercurial no trata de inferir cuando los
589 archivos han sido renombrados o copiados en un parche en este
590 momento.)
591 \item \command{patch} no puede representar ficheros vacíos, por lo
592 tanto no puede usar un parche para representar la noción ``Añadí
593 este fichero vacío al árbol''.
594 \end{itemize}
595 \subsection{Cuidado con los difusos}
597 Cuando aplique un trozo con un corrimiento, o con un factor difuso,
598 aveces será taotalmente exitoso, tales técnicas inexactas dejan
599 claramente la posibilidad de corromper el archivo parchado. Los casos
600 más típicos involucran aplicar un parche dos veces o en un sitio
601 incorrecto del fichero. Si \command{patch} o \hgxcmd{mq}{qpush} llegan
602 a mencionar un corrimiento o un factor difuso, debería asegurarse que
603 los ficheros modificados estén correctos después del suceso.
605 Casi siempre es buena idea refrescar un parche que fue aplicado con un
606 corrimiento o un factor difuso; refrescar el parche genera nueva
607 información de contexto que permitirá aplicarlo limpiamente. Digo
608 ``casi siempre,'' no ``siempre'', puesto que en ciertas ocasiones
609 refrescar un parche lo hará fallar frente a una revisión diferente del
610 fichero. En algunos casos, como por ejemplo, cuando usted está
611 manteniendo un parche que debe estar encima de múltiples revisiones de
612 un árbol de fuentes, es aceptable tener un parche aplicado algo
613 difuso, siempre que haya verificado los resultados del proceso de
614 parchar.
616 \subsection{Manejo de descartes}
618 Si \hgxcmd{mq}{qpush} falla al aplicar un parche, mostrará un texto de
619 error y saldrá. Si ha dejado ficheros \sfilename{.rej}, es mejor
620 arreglar los trozos descartados antes de introducir parches
621 adicionales o hacer cualquier otra cosa.
623 Si su parche \emph{solía} aplicarse limpiamente, y ya no lo hace
624 porque ha cambiado código subyacente en el cual se basa su parche, las
625 Colas de Mercurial pueden ayudar; consulte la sección~\ref{sec:mq:merge}.
627 Desafortunadamente, no hay grandes técnicas para tratar los trozos
628 descartados. Casi siempre deberá consultar el fichero
629 \sfilename{.rej} y editar el fichero objetivo, aplicando los trozos
630 descartados a mano.
632 Si es aventurero, Neil Brown, un hacker del núcleo Linux, escribió una
633 herramienta llamada \command{wiggle}~\cite{web:wiggle}, que es más
634 vigorosa que \command{patch} en su intento de hacer que se aplique un
635 parche.
637 Otro hacker del nucleo Linux, Chris Mason (el autor de las Colas de
638 Mercurial), escribió una herramienta similar llamada
639 \command{mpatch}~\cite{web:mpatch}, que sigue una aproximación
640 sencilla para automatizar la aplicación de trozos descartados por
641 \command{patch}. La orden \command{mpatch} puede ayudar con cuatro
642 razones comunes por las cuales un parche ha sido descartado:
644 \begin{itemize}
645 \item El contexto en la mitad de un trozo ha cambiado.
646 \item Un trozo ha perdido cierto contexto al principio o al final.
647 \item Un trozo largo podría aplicarse mejor---por completo o una
648 parte---si estaba cortado en trozos más pequeños.
649 \item Un trozo remueve líneas con contenido ligeramente diferente que
650 aquellas que están presentes en el fichero.
651 \end{itemize}
653 Si usted usa \command{wiggle} o \command{mpatch}, debería ser
654 doblemente cuidadoso al revisar sus resultados cuando haya terminado.
655 De hecho, \command{mpatch} refuerza este método de revisar por partida
656 doble su salida, dejándolo a usted en un programa de fusión cuando la
657 herramienta haya terminado su trabajo, de tal forma que usted pueda
658 verificar lo que ha hecho y pueda terminar de aplicar cualquier fusión
659 faltante.
661 \section{Contar con el máximo rendimiento de MQ}
662 \label{sec:mq:perf}
664 MQ es muy eficiente al tratar con una gran cantidad de parches. Corrí
665 unos experimentos de desempeño a mediados del 2006 para una charla que
666 dí en la conferencia EuroPython 2006~\cite{web:europython}. Empleé la
667 serie de parches para el núcleo Linux 2.6.17-mm1, que contaba con 1.738
668 parches. Los apliqué sobre un repositorio del núcleo de Linux con
669 todas las 27.472 revisiones entre 2.6.12-rc2 y 2.6.17.
671 En mi portátil antiguo y lento, logré aplicar
672 \hgcmdargs{qpush}{\hgxopt{mq}{qpush}{-a}} a los 1.738 parches en 3.5
673 minutos, y \hgcmdargs{qpop}{\hgxopt{mq}{qpop}{-a}} en 30 segundos.
674 (En un portátil más nuevo, el tiempo para introducir todos los
675 parches, se logró en menos de dos minutos.) Apliqué
676 \hgxcmd{mq}{qrefresh} sobre uno de los parches más grandes(que hizo
677 22.779 líneas de cambios en 287 ficheros) en 6,6 segundos.
679 Claramente, MQ funciona adecuadamente en árboles grandes, y además hay
680 unos trucos que pueden emplearse para obtener el máximo desempeño.
682 En primer lugar, trate de hacer ``en lote'' las operaciones. Cada vez
683 que ejecute \hgxcmd{mq}{qpush} o \hgxcmd{mq}{qpop}, tales órdenes
684 revisan el directorio de trabajo para asegurarse de que usted no ha
685 hecho cambios y ha olvidado ejecutar \hgxcmd{mq}{qrefresh}. En un
686 árbol pequeño, el tiempo de esta revisión puede ser mínimo, Pero en
687 un árbol mediano(con decenas de miles de ficheros), puede tomar un
688 segundo o más.
690 Las órdenes \hgxcmd{mq}{qpush} y \hgxcmd{mq}{qpop} le permiten
691 introducir o sustraer varios parches en una operación. Puede
692 identificar el ``parche destino'' que desee. Cuando aplique
693 \hgxcmd{mq}{qpush} con un destino, introducirá tantos parches como sea
694 necesario hasta que el especificado esté en el tope de la pila.
695 Cuando emplee \hgxcmd{mq}{qpop} con un destino, MQ sustraerá parches
696 hasta que el parche destino esté en el tope.
698 Puede identificar un parche destino con el nombre del parche o con el
699 número. Si se refiere al número, los parches se contarán desde cero;
700 esto significa que el primer parche es cero, el segundo es uno y así
701 sucesivamente.
703 \section{Actualiar los parches cuando el código cambia}
704 \label{sec:mq:merge}
706 Es común contar con una pila de parches sobre un repositorio que usted
707 no modifica directamente. Si está trabajando en cambios de código de
708 otros, o en una característica que tarda bastante en desarrollarse
709 comparada con la tasa de cambio del código sobre la cual se está
710 trabajando, necesitará sincronizarse con el código, y ajustar
711 cualquier trozo en sus parches que ya no estén al día. A esto se le
712 llama hacer \emph{rebase} a su serie de parches.
714 La vía más sencilla de hacerlo es con \hgcmdargs{qpop}{\hgxopt{mq}{qpop}{-a}}
715 sobre sus parches, después hacer \hgcmd{pull} de los cambios en el
716 repositorio, y finalmente hacer
717 \hgcmdargs{qpush}{\hgxopt{mq}{qpop}{-a}} con sus parches de nuevo. MQ
718 dejará de de introducir parches siempre que llegue a un parche que no se pueda
719 aplicar debido a un conflicto, permitiéndole a usted arreglarlo,
720 aplicar \hgxcmd{mq}{qrefresh} al parche afectado y continuar
721 introduciendo hasta que haya arreglado la pila completa.
723 Esta aproximación es sencilla y funciona bien si no espera cambios en
724 el código original que afecte en gran medida los parches que usted
725 esté aplicando. Si su pila de parches toca código que es modificado
726 frecuentemente o de forma invasiva sobre el código subyacente,
727 arreglar trozos manualmente se vuelve desgastante.
729 Es posible automatizar de forma parcial el proceso de rebase. Si sus
730 parches se aplican limpiamente sobre algunas revisiones del
731 repositorio subyacente, MQ puede usar esta información para ayudarle a
732 a resolver conflictos entre sus parches y una revisión distinta.
734 El proceso resulta un poco complejo:
735 \begin{enumerate}
736 \item Para comenzar, haga \hgcmdargs{qpush}{-a} sobre todos los
737 parches que usted sepa se aplican limpiamente.
738 \item Guarde una copia de seguridad de su directorio de parches con
739 \hgcmdargs{qsave}{\hgxopt{mq}{qsave}{-e} \hgxopt{mq}{qsave}{-c}}.
740 Esto imprime el nombre del directorio en el cual se han guardado los
741 parches. Guardará los parches en un directorio llamado
742 \sdirname{.hg/patches.\emph{N}}, donde \texttt{\emph{N}} es un
743 entero pequeño. También consigna un ``conjunto de cambios de
744 seguridad'' sobre sus parches aplicados; esto es para mantener el
745 histórico, y guarda los estados de los ficheros \sfilename{series}
746 y \sfilename{status}.
747 \item Use \hgcmd{pull} para traer los nuevos cambios en el repositorio
748 subyacente. (No ejecute \hgcmdargs{pull}{-u}; vea más adelante por qué.)
749 \item Actualice a la nueva revisión punta con
750 \hgcmdargs{update}{\hgopt{update}{-C}} para sobreescribir los
751 parches que haya introducido.
752 \item Fusione todos los parches con \hgcmdargs{qpush}{\hgxopt{mq}{qpush}{-m}
753 \hgxopt{mq}{qpush}{-a}}. La opción \hgxopt{mq}{qpush}{-m} de \hgxcmd{mq}{qpush}
754 le indica a MQ que haga una fusión que involucra tres fuentes si el
755 parche falla al aplicarse.
756 \end{enumerate}
758 Durante el \hgcmdargs{qpush}{\hgxopt{mq}{qpush}{-m}}, cada parche en
759 el fichero \sfilename{series} se aplica normalmente. Si un parche se
760 aplica difusamente o se niea a aplicarse, MQ consulta la cola que
761 usted guardó con \hgxcmd{mq}{qsave}, y aplica una fusión de tres con
762 el correspondiente conjunto de cambios. Esta fusión usa la maquinaria
763 de Mercurial, por lo tanto puede mostrar una herramienta de fusión GUI
764 para ayudarle a resolver los problemas.
766 Cuando termine de resolver los efectos de un parche, MQ refrescará su
767 parche basado en el resultado de la fusión.
769 Al final de este proceso, su repositorio tendrá una cabeza extra de la
770 antigua cola de parches, y una copia de la cola de parches anterio
771 estará en \sdirname{.hg/patches.\emph{N}}. Puede eliminar la cabeza
772 extra con \hgcmdargs{qpop}{\hgxopt{mq}{qpop}{-a} \hgxopt{mq}{qpop}{-n} patches.\emph{N}}
773 o \hgcmd{strip}. Puede eliminar \sdirname{.hg/patches.\emph{N}} una
774 vez que esté seguro de que no lo necesita más como copia de seguridad.
776 \section{Identificar parches}
778 Las órdenes de MQ le permiten trabajar refiriéndose al nombre del
779 parche o al número. Es obvio hacerlo por el nombre; por ejemplo se
780 pasa el nombre \filename{foo.patch} a \hgxcmd{mq}{qpush}, que
781 introducirá los parches hasta que \filename{foo.patch} se aplique.
783 Para hacerlo más corto, puede referirse a un parche con un nombre y un
784 corrimiento de número; por ejemplo, \texttt{foo.patch-2} significa
785 ``dos parches antes de \texttt{foo.patch}'', mientras que
786 \texttt{bar.patch+4} significa ``cuatro parches después de \texttt{bar.patch}''.
788 Referirse a un parche por su índice no es muy diferente. El primer
789 parche que se imprime en la salida de \hgxcmd{mq}{qseries} es el
790 parche cero(si, es el primero en los sistemas que comienzan su conteo
791 en cero); el segundo parche es uno y así sucesivamente.
793 MQ facilita el trabajo cuando está usando órdenes normales de
794 Mercurial. Cada comando que acepte Identificadores de conjuntos de
795 cambios también aceptará el nombre de un parche aplicado. MQ aumenta
796 los tags normalmente en el repositorio con un distintivo para cada
797 parche aplicado. Adicionalmente, los tags especiales \index{tags!special tag
798 names!\texttt{qbase}}\texttt{qbase} y \index{tags!special tag
799 names!\texttt{qtip}}\texttt{qtip} identifican los parches
800 ``primero'' y último, respectivamente.
802 These additions to Mercurial's normal tagging capabilities make
803 dealing with patches even more of a breeze.
804 \begin{itemize}
805 \item Want to patchbomb a mailing list with your latest series of
806 changes?
807 \begin{codesample4}
808 hg email qbase:qtip
809 \end{codesample4}
810 (Don't know what ``patchbombing'' is? See
811 section~\ref{sec:hgext:patchbomb}.)
812 \item Need to see all of the patches since \texttt{foo.patch} that
813 have touched files in a subdirectory of your tree?
814 \begin{codesample4}
815 hg log -r foo.patch:qtip \emph{subdir}
816 \end{codesample4}
817 \end{itemize}
819 Because MQ makes the names of patches available to the rest of
820 Mercurial through its normal internal tag machinery, you don't need to
821 type in the entire name of a patch when you want to identify it by
822 name.
824 \begin{figure}[ht]
825 \interaction{mq.id.output}
826 \caption{Using MQ's tag features to work with patches}
827 \label{ex:mq:id}
828 \end{figure}
830 Another nice consequence of representing patch names as tags is that
831 when you run the \hgcmd{log} command, it will display a patch's name
832 as a tag, simply as part of its normal output. This makes it easy to
833 visually distinguish applied patches from underlying ``normal''
834 revisions. Figure~\ref{ex:mq:id} shows a few normal Mercurial
835 commands in use with applied patches.
837 \section{Useful things to know about}
839 There are a number of aspects of MQ usage that don't fit tidily into
840 sections of their own, but that are good to know. Here they are, in
841 one place.
843 \begin{itemize}
844 \item Normally, when you \hgxcmd{mq}{qpop} a patch and \hgxcmd{mq}{qpush} it
845 again, the changeset that represents the patch after the pop/push
846 will have a \emph{different identity} than the changeset that
847 represented the hash beforehand. See
848 section~\ref{sec:mqref:cmd:qpush} for information as to why this is.
849 \item It's not a good idea to \hgcmd{merge} changes from another
850 branch with a patch changeset, at least if you want to maintain the
851 ``patchiness'' of that changeset and changesets below it on the
852 patch stack. If you try to do this, it will appear to succeed, but
853 MQ will become confused.
854 \end{itemize}
856 \section{Managing patches in a repository}
857 \label{sec:mq:repo}
859 Because MQ's \sdirname{.hg/patches} directory resides outside a
860 Mercurial repository's working directory, the ``underlying'' Mercurial
861 repository knows nothing about the management or presence of patches.
863 This presents the interesting possibility of managing the contents of
864 the patch directory as a Mercurial repository in its own right. This
865 can be a useful way to work. For example, you can work on a patch for
866 a while, \hgxcmd{mq}{qrefresh} it, then \hgcmd{commit} the current state of
867 the patch. This lets you ``roll back'' to that version of the patch
868 later on.
870 You can then share different versions of the same patch stack among
871 multiple underlying repositories. I use this when I am developing a
872 Linux kernel feature. I have a pristine copy of my kernel sources for
873 each of several CPU architectures, and a cloned repository under each
874 that contains the patches I am working on. When I want to test a
875 change on a different architecture, I push my current patches to the
876 patch repository associated with that kernel tree, pop and push all of
877 my patches, and build and test that kernel.
879 Managing patches in a repository makes it possible for multiple
880 developers to work on the same patch series without colliding with
881 each other, all on top of an underlying source base that they may or
882 may not control.
884 \subsection{MQ support for patch repositories}
886 MQ helps you to work with the \sdirname{.hg/patches} directory as a
887 repository; when you prepare a repository for working with patches
888 using \hgxcmd{mq}{qinit}, you can pass the \hgxopt{mq}{qinit}{-c} option to
889 create the \sdirname{.hg/patches} directory as a Mercurial repository.
891 \begin{note}
892 If you forget to use the \hgxopt{mq}{qinit}{-c} option, you can simply go
893 into the \sdirname{.hg/patches} directory at any time and run
894 \hgcmd{init}. Don't forget to add an entry for the
895 \sfilename{status} file to the \sfilename{.hgignore} file, though
897 (\hgcmdargs{qinit}{\hgxopt{mq}{qinit}{-c}} does this for you
898 automatically); you \emph{really} don't want to manage the
899 \sfilename{status} file.
900 \end{note}
902 As a convenience, if MQ notices that the \dirname{.hg/patches}
903 directory is a repository, it will automatically \hgcmd{add} every
904 patch that you create and import.
906 MQ provides a shortcut command, \hgxcmd{mq}{qcommit}, that runs
907 \hgcmd{commit} in the \sdirname{.hg/patches} directory. This saves
908 some bothersome typing.
910 Finally, as a convenience to manage the patch directory, you can
911 define the alias \command{mq} on Unix systems. For example, on Linux
912 systems using the \command{bash} shell, you can include the following
913 snippet in your \tildefile{.bashrc}.
915 \begin{codesample2}
916 alias mq=`hg -R \$(hg root)/.hg/patches'
917 \end{codesample2}
919 You can then issue commands of the form \cmdargs{mq}{pull} from
920 the main repository.
922 \subsection{A few things to watch out for}
924 MQ's support for working with a repository full of patches is limited
925 in a few small respects.
927 MQ cannot automatically detect changes that you make to the patch
928 directory. If you \hgcmd{pull}, manually edit, or \hgcmd{update}
929 changes to patches or the \sfilename{series} file, you will have to
930 \hgcmdargs{qpop}{\hgxopt{mq}{qpop}{-a}} and then
931 \hgcmdargs{qpush}{\hgxopt{mq}{qpush}{-a}} in the underlying repository to
932 see those changes show up there. If you forget to do this, you can
933 confuse MQ's idea of which patches are applied.
935 \section{Third party tools for working with patches}
936 \label{sec:mq:tools}
938 Once you've been working with patches for a while, you'll find
939 yourself hungry for tools that will help you to understand and
940 manipulate the patches you're dealing with.
942 The \command{diffstat} command~\cite{web:diffstat} generates a
943 histogram of the modifications made to each file in a patch. It
944 provides a good way to ``get a sense of'' a patch---which files it
945 affects, and how much change it introduces to each file and as a
946 whole. (I find that it's a good idea to use \command{diffstat}'s
947 \cmdopt{diffstat}{-p} option as a matter of course, as otherwise it
948 will try to do clever things with prefixes of file names that
949 inevitably confuse at least me.)
951 \begin{figure}[ht]
952 \interaction{mq.tools.tools}
953 \caption{The \command{diffstat}, \command{filterdiff}, and \command{lsdiff} commands}
954 \label{ex:mq:tools}
955 \end{figure}
957 The \package{patchutils} package~\cite{web:patchutils} is invaluable.
958 It provides a set of small utilities that follow the ``Unix
959 philosophy;'' each does one useful thing with a patch. The
960 \package{patchutils} command I use most is \command{filterdiff}, which
961 extracts subsets from a patch file. For example, given a patch that
962 modifies hundreds of files across dozens of directories, a single
963 invocation of \command{filterdiff} can generate a smaller patch that
964 only touches files whose names match a particular glob pattern. See
965 section~\ref{mq-collab:tips:interdiff} for another example.
967 \section{Good ways to work with patches}
969 Whether you are working on a patch series to submit to a free software
970 or open source project, or a series that you intend to treat as a
971 sequence of regular changesets when you're done, you can use some
972 simple techniques to keep your work well organised.
974 Give your patches descriptive names. A good name for a patch might be
975 \filename{rework-device-alloc.patch}, because it will immediately give
976 you a hint what the purpose of the patch is. Long names shouldn't be
977 a problem; you won't be typing the names often, but you \emph{will} be
978 running commands like \hgxcmd{mq}{qapplied} and \hgxcmd{mq}{qtop} over and over.
979 Good naming becomes especially important when you have a number of
980 patches to work with, or if you are juggling a number of different
981 tasks and your patches only get a fraction of your attention.
983 Be aware of what patch you're working on. Use the \hgxcmd{mq}{qtop}
984 command and skim over the text of your patches frequently---for
985 example, using \hgcmdargs{tip}{\hgopt{tip}{-p}})---to be sure of where
986 you stand. I have several times worked on and \hgxcmd{mq}{qrefresh}ed a
987 patch other than the one I intended, and it's often tricky to migrate
988 changes into the right patch after making them in the wrong one.
990 For this reason, it is very much worth investing a little time to
991 learn how to use some of the third-party tools I described in
992 section~\ref{sec:mq:tools}, particularly \command{diffstat} and
993 \command{filterdiff}. The former will give you a quick idea of what
994 changes your patch is making, while the latter makes it easy to splice
995 hunks selectively out of one patch and into another.
997 \section{MQ cookbook}
999 \subsection{Manage ``trivial'' patches}
1001 Because the overhead of dropping files into a new Mercurial repository
1002 is so low, it makes a lot of sense to manage patches this way even if
1003 you simply want to make a few changes to a source tarball that you
1004 downloaded.
1006 Begin by downloading and unpacking the source tarball,
1007 and turning it into a Mercurial repository.
1008 \interaction{mq.tarball.download}
1010 Continue by creating a patch stack and making your changes.
1011 \interaction{mq.tarball.qinit}
1013 Let's say a few weeks or months pass, and your package author releases
1014 a new version. First, bring their changes into the repository.
1015 \interaction{mq.tarball.newsource}
1016 The pipeline starting with \hgcmd{locate} above deletes all files in
1017 the working directory, so that \hgcmd{commit}'s
1018 \hgopt{commit}{--addremove} option can actually tell which files have
1019 really been removed in the newer version of the source.
1021 Finally, you can apply your patches on top of the new tree.
1022 \interaction{mq.tarball.repush}
1024 \subsection{Combining entire patches}
1025 \label{sec:mq:combine}
1027 MQ provides a command, \hgxcmd{mq}{qfold} that lets you combine entire
1028 patches. This ``folds'' the patches you name, in the order you name
1029 them, into the topmost applied patch, and concatenates their
1030 descriptions onto the end of its description. The patches that you
1031 fold must be unapplied before you fold them.
1033 The order in which you fold patches matters. If your topmost applied
1034 patch is \texttt{foo}, and you \hgxcmd{mq}{qfold} \texttt{bar} and
1035 \texttt{quux} into it, you will end up with a patch that has the same
1036 effect as if you applied first \texttt{foo}, then \texttt{bar},
1037 followed by \texttt{quux}.
1039 \subsection{Merging part of one patch into another}
1041 Merging \emph{part} of one patch into another is more difficult than
1042 combining entire patches.
1044 If you want to move changes to entire files, you can use
1045 \command{filterdiff}'s \cmdopt{filterdiff}{-i} and
1046 \cmdopt{filterdiff}{-x} options to choose the modifications to snip
1047 out of one patch, concatenating its output onto the end of the patch
1048 you want to merge into. You usually won't need to modify the patch
1049 you've merged the changes from. Instead, MQ will report some rejected
1050 hunks when you \hgxcmd{mq}{qpush} it (from the hunks you moved into the
1051 other patch), and you can simply \hgxcmd{mq}{qrefresh} the patch to drop
1052 the duplicate hunks.
1054 If you have a patch that has multiple hunks modifying a file, and you
1055 only want to move a few of those hunks, the job becomes more messy,
1056 but you can still partly automate it. Use \cmdargs{lsdiff}{-nvv} to
1057 print some metadata about the patch.
1058 \interaction{mq.tools.lsdiff}
1060 This command prints three different kinds of number:
1061 \begin{itemize}
1062 \item (in the first column) a \emph{file number} to identify each file
1063 modified in the patch;
1064 \item (on the next line, indented) the line number within a modified
1065 file where a hunk starts; and
1066 \item (on the same line) a \emph{hunk number} to identify that hunk.
1067 \end{itemize}
1069 You'll have to use some visual inspection, and reading of the patch,
1070 to identify the file and hunk numbers you'll want, but you can then
1071 pass them to to \command{filterdiff}'s \cmdopt{filterdiff}{--files}
1072 and \cmdopt{filterdiff}{--hunks} options, to select exactly the file
1073 and hunk you want to extract.
1075 Once you have this hunk, you can concatenate it onto the end of your
1076 destination patch and continue with the remainder of
1077 section~\ref{sec:mq:combine}.
1079 \section{Differences between quilt and MQ}
1081 If you are already familiar with quilt, MQ provides a similar command
1082 set. There are a few differences in the way that it works.
1084 You will already have noticed that most quilt commands have MQ
1085 counterparts that simply begin with a ``\texttt{q}''. The exceptions
1086 are quilt's \texttt{add} and \texttt{remove} commands, the
1087 counterparts for which are the normal Mercurial \hgcmd{add} and
1088 \hgcmd{remove} commands. There is no MQ equivalent of the quilt
1089 \texttt{edit} command.
1091 %%% Local Variables:
1092 %%% mode: latex
1093 %%% TeX-master: "00book"
1094 %%% End: