$ "$TESTDIR/hghave" execbit || exit 80

  $ 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.

  It may be desirable for mq changesets to be kept in the secret phase (see "hg

  help phases"), which can be enabled with the following setting:

    [mq]

    secret = True

  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 or existing changeset

   qnew          create a new patch

   qnext         print the name of the next pushable patch

   qpop          pop the current patch off the stack

   qprev         print the name of the preceding applied 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! (glob)

  [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 phase -r qbase

  0: draft

  $ hg add foo

  $ hg qrefresh

  $ hg phase -r qbase

  0: draft

  $ hg qnew B

  $ echo >> foo

  $ hg qrefresh

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

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

  $ hg qinit -c

  adding .hg/patches/A (glob)

  adding .hg/patches/B (glob)

  $ 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 phase -r qbase

  2: draft

  $ 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