$ checkundo()

  > {

  >     if [ -f .hg/store/undo ]; then

  >     echo ".hg/store/undo still exists after $1"

  >     fi

  > }

  $ echo "[extensions]" >> $HGRCPATH

  $ echo "mq=" >> $HGRCPATH

  $ echo "[mq]" >> $HGRCPATH

  $ echo "plain=true" >> $HGRCPATH

help

  $ hg help mq

  mq extension - manage a stack of patches

  This extension lets you work with a stack of patches in a Mercurial

  repository. It manages two stacks of patches - all known patches, and applied

  patches (subset of known patches).

  Known patches are represented as patch files in the .hg/patches directory.

  Applied patches are both patch files and changesets.

  Common tasks (use "hg help command" for more details):

    create new patch                          qnew

    import existing patch                     qimport

    print patch series                        qseries

    print applied patches                     qapplied

    add known patch to applied stack          qpush

    remove patch from applied stack           qpop

    refresh contents of top applied patch     qrefresh

  By default, mq will automatically use git patches when required to avoid

  losing file mode changes, copy records, binary files or empty files creations

  or deletions. This behaviour can be configured with:

    [mq]

    git = auto/keep/yes/no

  If set to 'keep', mq will obey the [diff] section configuration while

  preserving existing git patches upon qrefresh. If set to 'yes' or 'no', mq

  will override the [diff] section and always generate git or regular patches,

  possibly losing data in the second case.

  You will by default be managing a patch queue named "patches". You can create

  other, independent patch queues with the "hg qqueue" command.

  list of commands:

   qapplied     print the patches already applied

   qclone       clone main and patch repository at same time

   qdelete      remove patches from queue

   qdiff        diff of the current patch and subsequent modifications

   qfinish      move applied patches into repository history

   qfold        fold the named patches into the current patch

   qgoto        push or pop patches until named patch is at top of stack

   qguard       set or print guards for a patch

   qheader      print the header of the topmost or specified patch

   qimport      import a patch

   qnew         create a new patch

   qnext        print the name of the next patch

   qpop         pop the current patch off the stack

   qprev        print the name of the previous patch

   qpush        push the next patch onto the stack

   qqueue       manage multiple patch queues

   qrefresh     update the current patch

   qrename      rename a patch

   qselect      set or print guarded patches to push

   qseries      print the entire series file

   qtop         print the name of the current patch

   qunapplied   print the patches not yet applied

   strip        strip changesets and all their descendants from the repository

  use "hg -v help mq" to show builtin aliases and global options

  $ hg init a

  $ cd a

  $ echo a > a

  $ hg ci -Ama

  adding a

  $ hg clone . ../k

  updating to branch default

  1 files updated, 0 files merged, 0 files removed, 0 files unresolved

  $ mkdir b

  $ echo z > b/z

  $ hg ci -Ama

  adding b/z

qinit

  $ hg qinit

  $ cd ..

  $ hg init b

-R qinit

  $ hg -R b qinit

  $ hg init c

qinit -c

  $ hg --cwd c qinit -c

  $ hg -R c/.hg/patches st

  A .hgignore

  A series

qinit; qinit -c

  $ hg init d

  $ cd d

  $ hg qinit

  $ hg qinit -c

qinit -c should create both files if they don't exist

  $ cat .hg/patches/.hgignore

  ^\.hg

  ^\.mq

  syntax: glob

  status

  guards

  $ cat .hg/patches/series

  $ hg qinit -c

  abort: repository $TESTTMP/d/.hg/patches already exists!

  [255]

  $ cd ..

  $ echo '% qinit; <stuff>; qinit -c'

  % qinit; <stuff>; qinit -c

  $ hg init e

  $ cd e

  $ hg qnew A

  $ checkundo qnew

  $ echo foo > foo

  $ hg add foo

  $ hg qrefresh

  $ hg qnew B

  $ echo >> foo

  $ hg qrefresh

  $ echo status >> .hg/patches/.hgignore

  $ echo bleh >> .hg/patches/.hgignore

  $ hg qinit -c

  adding .hg/patches/A

  adding .hg/patches/B

  $ hg -R .hg/patches status

  A .hgignore

  A A

  A B

  A series

qinit -c shouldn't touch these files if they already exist

  $ cat .hg/patches/.hgignore

  status

  bleh

  $ cat .hg/patches/series

  A

  B

add an untracked file

  $ echo >> .hg/patches/flaf

status --mq with color (issue2096)

  $ hg status --mq --config extensions.color= --config color.mode=ansi --color=always

  \x1b[0;32;1mA .hgignore\x1b[0m (esc)

  \x1b[0;32;1mA A\x1b[0m (esc)

  \x1b[0;32;1mA B\x1b[0m (esc)

  \x1b[0;32;1mA series\x1b[0m (esc)

  \x1b[0;35;1;4m? flaf\x1b[0m (esc)

try the --mq option on a command provided by an extension

  $ hg purge --mq --verbose --config extensions.purge=

  Removing file flaf

  $ cd ..

init --mq without repo

  $ mkdir f

  $ cd f

  $ hg init --mq

  abort: there is no Mercurial repository here (.hg not found)

  [255]

  $ cd ..

init --mq with repo path

  $ hg init g

  $ hg init --mq g

  $ test -d g/.hg/patches/.hg

init --mq with nonexistent directory

  $ hg init --mq nonexistentdir

  abort: repository nonexistentdir not found!

  [255]

init --mq with bundle (non "local")

  $ hg -R a bundle --all a.bundle >/dev/null

  $ hg init --mq a.bundle

  abort: only a local queue repository may be initialized

  [255]

  $ cd a

  $ hg qnew -m 'foo bar' test.patch

  $ echo '# comment' > .hg/patches/series.tmp

  $ echo >> .hg/patches/series.tmp # empty line

  $ cat .hg/patches/series >> .hg/patches/series.tmp

  $ mv .hg/patches/series.tmp .hg/patches/series

qrefresh

  $ echo a >> a

  $ hg qrefresh

  $ cat .hg/patches/test.patch

  foo bar

  diff -r [a-f0-9]* a (re)

  --- a/a\t(?P<date>.*) (re)

  \+\+\+ b/a\t(?P<date2>.*) (re)

  @@ -1,1 +1,2 @@

   a

  +a

empty qrefresh

  $ hg qrefresh -X a

revision:

  $ hg diff -r -2 -r -1

patch:

  $ cat .hg/patches/test.patch

  foo bar

working dir diff:

  $ hg diff --nodates -q

  --- a/a

  +++ b/a

  @@ -1,1 +1,2 @@

   a

  +a

restore things

  $ hg qrefresh

  $ checkundo qrefresh

qpop

  $ hg qpop

  popping test.patch

  patch queue now empty

  $ checkundo qpop

qpush with dump of tag cache

Dump the tag cache to ensure that it has exactly one head after qpush.

  $ rm -f .hg/cache/tags

  $ hg tags > /dev/null

.hg/cache/tags (pre qpush):

  $ cat .hg/cache/tags

  1 [\da-f]{40} (re)

  $ hg qpush

  applying test.patch

  now at: test.patch

  $ hg tags > /dev/null

.hg/cache/tags (post qpush):

  $ cat .hg/cache/tags

  2 [\da-f]{40} (re)

  $ checkundo qpush

  $ cd ..

pop/push outside repo

  $ hg -R a qpop

  popping test.patch

  patch queue now empty

  $ hg -R a qpush

  applying test.patch

  now at: test.patch

  $ cd a

  $ hg qnew test2.patch

qrefresh in subdir

  $ cd b

  $ echo a > a

  $ hg add a

  $ hg qrefresh

pop/push -a in subdir

  $ hg qpop -a

  popping test2.patch

  popping test.patch

  patch queue now empty

  $ hg --traceback qpush -a

  applying test.patch

  applying test2.patch

  now at: test2.patch

setting columns & formatted tests truncating (issue1912)

  $ COLUMNS=4 hg qseries --config ui.formatted=true

  test.patch

  test2.patch

  $ COLUMNS=20 hg qseries --config ui.formatted=true -vs

  0 A test.patch: f...

  1 A test2.patch: 

  $ hg qpop

  popping test2.patch

  now at: test.patch

  $ hg qseries -vs

  0 A test.patch: foo bar

  1 U test2.patch: 

  $ hg sum | grep mq

  mq:     1 applied, 1 unapplied

  $ hg qpush

  applying test2.patch

  now at: test2.patch

  $ hg sum | grep mq

  mq:     2 applied

  $ hg qapplied

  test.patch

  test2.patch

  $ hg qtop

  test2.patch

prev

  $ hg qapp -1

  test.patch

next

  $ hg qunapp -1

  all patches applied

  [1]

  $ hg qpop

  popping test2.patch

  now at: test.patch

commit should fail

  $ hg commit

  abort: cannot commit over an applied mq patch

  [255]

push should fail