destutil: raise more specific error when histedit.defaultrev is empty

Differential Revision: https://phab.mercurial-scm.org/D9313

mercurial/destutil.py

@@ -1,490 +1,490 b''
 # destutil.py - Mercurial utility function for command destination
 #
 #  Copyright Matt Mackall <[e-mail]> and other
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 from .i18n import _
 from . import bookmarks, error, obsutil, scmutil, stack
 
 
 def orphanpossibledestination(repo, rev):
     """Return all changesets that may be a new parent for orphan `rev`.
 
     This function works fine on non-orphan revisions, it's just silly
     because there's no destination implied by obsolete markers, so
     it'll return nothing.
     """
     tonode = repo.changelog.node
     parents = repo.changelog.parentrevs
     torev = repo.changelog.rev
     dest = set()
     tovisit = list(parents(rev))
     while tovisit:
         r = tovisit.pop()
         succsets = obsutil.successorssets(repo, tonode(r))
         if not succsets:
             # if there are no successors for r, r was probably pruned
             # and we should walk up to r's parents to try and find
             # some successors.
             tovisit.extend(parents(r))
         else:
             # We should probably pick only one destination from split
             # (case where '1 < len(ss)'), This could be the currently
             # tipmost, but the correct result is less clear when
             # results of the split have been moved such that they
             # reside on multiple branches.
             for ss in succsets:
                 for n in ss:
                     dr = torev(n)
                     if dr != -1:
                         dest.add(dr)
     return dest
 
 
 def _destupdateobs(repo, clean):
     """decide of an update destination from obsolescence markers"""
     node = None
     wc = repo[None]
     p1 = wc.p1()
     movemark = None
 
     if p1.obsolete() and not p1.children():
         # allow updating to successors
         successors = obsutil.successorssets(repo, p1.node())
 
         # behavior of certain cases is as follows,
         #
         # divergent changesets: update to highest rev, similar to what
         #     is currently done when there are more than one head
         #     (i.e. 'tip')
         #
         # replaced changesets: same as divergent except we know there
         # is no conflict
         #
         # pruned changeset: no update is done; though, we could
         #     consider updating to the first non-obsolete parent,
         #     similar to what is current done for 'hg prune'
 
         if successors:
             # flatten the list here handles both divergent (len > 1)
             # and the usual case (len = 1)
             successors = [n for sub in successors for n in sub]
 
             # get the max revision for the given successors set,
             # i.e. the 'tip' of a set
             node = repo.revs(b'max(%ln)', successors).first()
             if bookmarks.isactivewdirparent(repo):
                 movemark = repo[b'.'].node()
     return node, movemark, None
 
 
 def _destupdatebook(repo, clean):
     """decide on an update destination from active bookmark"""
     # we also move the active bookmark, if any
     node = None
     activemark, movemark = bookmarks.calculateupdate(repo.ui, repo)
     if activemark is not None:
         node = repo._bookmarks[activemark]
     return node, movemark, activemark
 
 
 def _destupdatebranch(repo, clean):
     """decide on an update destination from current branch
 
     This ignores closed branch heads.
     """
     wc = repo[None]
     movemark = node = None
     currentbranch = wc.branch()
 
     if clean:
         currentbranch = repo[b'.'].branch()
 
     if currentbranch in repo.branchmap():
         heads = repo.branchheads(currentbranch)
         if heads:
             node = repo.revs(b'max(.::(%ln))', heads).first()
         if bookmarks.isactivewdirparent(repo):
             movemark = repo[b'.'].node()
     elif currentbranch == b'default' and not wc.p1():
         # "null" parent belongs to "default" branch, but it doesn't exist, so
         # update to the tipmost non-closed branch head
         node = repo.revs(b'max(head() and not closed())').first()
     else:
         node = repo[b'.'].node()
     return node, movemark, None
 
 
 def _destupdatebranchfallback(repo, clean):
     """decide on an update destination from closed heads in current branch"""
     wc = repo[None]
     currentbranch = wc.branch()
     movemark = None
     if currentbranch in repo.branchmap():
         # here, all descendant branch heads are closed
         heads = repo.branchheads(currentbranch, closed=True)
         assert heads, b"any branch has at least one head"
         node = repo.revs(b'max(.::(%ln))', heads).first()
         assert (
             node is not None
         ), b"any revision has at least one descendant branch head"
         if bookmarks.isactivewdirparent(repo):
             movemark = repo[b'.'].node()
     else:
         # here, no "default" branch, and all branches are closed
         node = repo.lookup(b'tip')
         assert node is not None, b"'tip' exists even in empty repository"
     return node, movemark, None
 
 
 # order in which each step should be evaluated
 # steps are run until one finds a destination
 destupdatesteps = [b'evolution', b'bookmark', b'branch', b'branchfallback']
 # mapping to ease extension overriding steps.
 destupdatestepmap = {
     b'evolution': _destupdateobs,
     b'bookmark': _destupdatebook,
     b'branch': _destupdatebranch,
     b'branchfallback': _destupdatebranchfallback,
 }
 
 
 def destupdate(repo, clean=False):
     """destination for bare update operation
 
     return (rev, movemark, activemark)
 
     - rev: the revision to update to,
     - movemark: node to move the active bookmark from
                 (cf bookmark.calculate update),
     - activemark: a bookmark to activate at the end of the update.
     """
     node = movemark = activemark = None
 
     for step in destupdatesteps:
         node, movemark, activemark = destupdatestepmap[step](repo, clean)
         if node is not None:
             break
     rev = repo[node].rev()
 
     return rev, movemark, activemark
 
 
 msgdestmerge = {
     # too many matching divergent bookmark
     b'toomanybookmarks': {
         b'merge': (
             _(
                 b"multiple matching bookmarks to merge -"
                 b" please merge with an explicit rev or bookmark"
             ),
             _(b"run 'hg heads' to see all heads, specify rev with -r"),
         ),
         b'rebase': (
             _(
                 b"multiple matching bookmarks to rebase -"
                 b" please rebase to an explicit rev or bookmark"
             ),
             _(b"run 'hg heads' to see all heads, specify destination with -d"),
         ),
     },
     # no other matching divergent bookmark
     b'nootherbookmarks': {
         b'merge': (
             _(
                 b"no matching bookmark to merge - "
                 b"please merge with an explicit rev or bookmark"
             ),
             _(b"run 'hg heads' to see all heads, specify rev with -r"),
         ),
         b'rebase': (
             _(
                 b"no matching bookmark to rebase - "
                 b"please rebase to an explicit rev or bookmark"
             ),
             _(b"run 'hg heads' to see all heads, specify destination with -d"),
         ),
     },
     # branch have too many unbookmarked heads, no obvious destination
     b'toomanyheads': {
         b'merge': (
             _(b"branch '%s' has %d heads - please merge with an explicit rev"),
             _(b"run 'hg heads .' to see heads, specify rev with -r"),
         ),
         b'rebase': (
             _(b"branch '%s' has %d heads - please rebase to an explicit rev"),
             _(b"run 'hg heads .' to see heads, specify destination with -d"),
         ),
     },
     # branch have no other unbookmarked heads
     b'bookmarkedheads': {
         b'merge': (
             _(b"heads are bookmarked - please merge with an explicit rev"),
             _(b"run 'hg heads' to see all heads, specify rev with -r"),
         ),
         b'rebase': (
             _(b"heads are bookmarked - please rebase to an explicit rev"),
             _(b"run 'hg heads' to see all heads, specify destination with -d"),
         ),
     },
     # branch have just a single heads, but there is other branches
     b'nootherbranchheads': {
         b'merge': (
             _(b"branch '%s' has one head - please merge with an explicit rev"),
             _(b"run 'hg heads' to see all heads, specify rev with -r"),
         ),
         b'rebase': (
             _(b"branch '%s' has one head - please rebase to an explicit rev"),
             _(b"run 'hg heads' to see all heads, specify destination with -d"),
         ),
     },
     # repository have a single head
     b'nootherheads': {
         b'merge': (_(b'nothing to merge'), None),
         b'rebase': (_(b'nothing to rebase'), None),
     },
     # repository have a single head and we are not on it
     b'nootherheadsbehind': {
         b'merge': (_(b'nothing to merge'), _(b"use 'hg update' instead")),
         b'rebase': (_(b'nothing to rebase'), _(b"use 'hg update' instead")),
     },
     # We are not on a head
     b'notatheads': {
         b'merge': (
             _(b'working directory not at a head revision'),
             _(b"use 'hg update' or merge with an explicit revision"),
         ),
         b'rebase': (
             _(b'working directory not at a head revision'),
             _(b"use 'hg update' or rebase to an explicit revision"),
         ),
     },
     b'emptysourceset': {
         b'merge': (_(b'source set is empty'), None),
         b'rebase': (_(b'source set is empty'), None),
     },
     b'multiplebranchessourceset': {
         b'merge': (_(b'source set is rooted in multiple branches'), None),
         b'rebase': (
             _(b'rebaseset is rooted in multiple named branches'),
             _(b'specify an explicit destination with --dest'),
         ),
     },
 }
 
 
 def _destmergebook(repo, action=b'merge', sourceset=None, destspace=None):
     """find merge destination in the active bookmark case"""
     node = None
     bmheads = bookmarks.headsforactive(repo)
     curhead = repo._bookmarks[repo._activebookmark]
     if len(bmheads) == 2:
         if curhead == bmheads[0]:
             node = bmheads[1]
         else:
             node = bmheads[0]
     elif len(bmheads) > 2:
         msg, hint = msgdestmerge[b'toomanybookmarks'][action]
         raise error.ManyMergeDestAbort(msg, hint=hint)
     elif len(bmheads) <= 1:
         msg, hint = msgdestmerge[b'nootherbookmarks'][action]
         raise error.NoMergeDestAbort(msg, hint=hint)
     assert node is not None
     return node
 
 
 def _destmergebranch(
     repo, action=b'merge', sourceset=None, onheadcheck=True, destspace=None
 ):
     """find merge destination based on branch heads"""
     node = None
 
     if sourceset is None:
         sourceset = [repo[repo.dirstate.p1()].rev()]
         branch = repo.dirstate.branch()
     elif not sourceset:
         msg, hint = msgdestmerge[b'emptysourceset'][action]
         raise error.NoMergeDestAbort(msg, hint=hint)
     else:
         branch = None
         for ctx in repo.set(b'roots(%ld::%ld)', sourceset, sourceset):
             if branch is not None and ctx.branch() != branch:
                 msg, hint = msgdestmerge[b'multiplebranchessourceset'][action]
                 raise error.ManyMergeDestAbort(msg, hint=hint)
             branch = ctx.branch()
 
     bheads = repo.branchheads(branch)
     onhead = repo.revs(b'%ld and %ln', sourceset, bheads)
     if onheadcheck and not onhead:
         # Case A: working copy if not on a head. (merge only)
         #
         # This is probably a user mistake We bailout pointing at 'hg update'
         if len(repo.heads()) <= 1:
             msg, hint = msgdestmerge[b'nootherheadsbehind'][action]
         else:
             msg, hint = msgdestmerge[b'notatheads'][action]
         raise error.Abort(msg, hint=hint)
     # remove heads descendants of source from the set
     bheads = list(repo.revs(b'%ln - (%ld::)', bheads, sourceset))
     # filters out bookmarked heads
     nbhs = list(repo.revs(b'%ld - bookmark()', bheads))
 
     if destspace is not None:
         # restrict search space
         # used in the 'hg pull --rebase' case, see issue 5214.
         nbhs = list(repo.revs(b'%ld and %ld', destspace, nbhs))
 
     if len(nbhs) > 1:
         # Case B: There is more than 1 other anonymous heads
         #
         # This means that there will be more than 1 candidate. This is
         # ambiguous. We abort asking the user to pick as explicit destination
         # instead.
         msg, hint = msgdestmerge[b'toomanyheads'][action]
         msg %= (branch, len(bheads) + 1)
         raise error.ManyMergeDestAbort(msg, hint=hint)
     elif not nbhs:
         # Case B: There is no other anonymous heads
         #
         # This means that there is no natural candidate to merge with.
         # We abort, with various messages for various cases.
         if bheads:
             msg, hint = msgdestmerge[b'bookmarkedheads'][action]
         elif len(repo.heads()) > 1:
             msg, hint = msgdestmerge[b'nootherbranchheads'][action]
             msg %= branch
         elif not onhead:
             # if 'onheadcheck == False' (rebase case),
             # this was not caught in Case A.
             msg, hint = msgdestmerge[b'nootherheadsbehind'][action]
         else:
             msg, hint = msgdestmerge[b'nootherheads'][action]
         raise error.NoMergeDestAbort(msg, hint=hint)
     else:
         node = nbhs[0]
     assert node is not None
     return node
 
 
 def destmerge(
     repo, action=b'merge', sourceset=None, onheadcheck=True, destspace=None
 ):
     """return the default destination for a merge
 
     (or raise exception about why it can't pick one)
 
     :action: the action being performed, controls emitted error message
     """
     # destspace is here to work around issues with `hg pull --rebase` see
     # issue5214 for details
     if repo._activebookmark:
         node = _destmergebook(
             repo, action=action, sourceset=sourceset, destspace=destspace
         )
     else:
         node = _destmergebranch(
             repo,
             action=action,
             sourceset=sourceset,
             onheadcheck=onheadcheck,
             destspace=destspace,
         )
     return repo[node].rev()
 
 
 def desthistedit(ui, repo):
     """Default base revision to edit for `hg histedit`."""
     default = ui.config(b'histedit', b'defaultrev')
 
     if default is None:
         revs = stack.getstack(repo)
     elif default:
         revs = scmutil.revrange(repo, [default])
     else:
-        raise error.Abort(
+        raise error.ConfigError(
             _(b"config option histedit.defaultrev can't be empty")
         )
 
     if revs:
         # Take the first revision of the revset as the root
         return revs.min()
 
     return None
 
 
 def stackbase(ui, repo):
     revs = stack.getstack(repo)
     return revs.first() if revs else None
 
 
 def _statusotherbook(ui, repo):
     bmheads = bookmarks.headsforactive(repo)
     curhead = repo._bookmarks[repo._activebookmark]
     if repo.revs(b'%n and parents()', curhead):
         # we are on the active bookmark
         bmheads = [b for b in bmheads if curhead != b]
         if bmheads:
             msg = _(b'%i other divergent bookmarks for "%s"\n')
             ui.status(msg % (len(bmheads), repo._activebookmark))
 
 
 def _statusotherbranchheads(ui, repo):
     currentbranch = repo.dirstate.branch()
     allheads = repo.branchheads(currentbranch, closed=True)
     heads = repo.branchheads(currentbranch)
     if repo.revs(b'%ln and parents()', allheads):
         # we are on a head, even though it might be closed
         #
         #  on closed otherheads
         #  ========= ==========
         #      o        0       all heads for current branch are closed
         #               N       only descendant branch heads are closed
         #      x        0       there is only one non-closed branch head
         #               N       there are some non-closed branch heads
         #  ========= ==========
         otherheads = repo.revs(b'%ln - parents()', heads)
         if repo[b'.'].closesbranch():
             ui.warn(
                 _(
                     b'no open descendant heads on branch "%s", '
                     b'updating to a closed head\n'
                 )
                 % currentbranch
             )
             if otherheads:
                 ui.warn(
                     _(
                         b"(committing will reopen the head, "
                         b"use 'hg heads .' to see %i other heads)\n"
                     )
                     % (len(otherheads))
                 )
             else:
                 ui.warn(
                     _(b'(committing will reopen branch "%s")\n') % currentbranch
                 )
         elif otherheads:
             curhead = repo[b'.']
             ui.status(
                 _(b'updated to "%s: %s"\n')
                 % (curhead, curhead.description().split(b'\n')[0])
             )
             ui.status(
                 _(b'%i other heads for branch "%s"\n')
                 % (len(otherheads), currentbranch)
             )
 
 
 def statusotherdests(ui, repo):
     """Print message about other head"""
     # XXX we should probably include a hint:
     # - about what to do
     # - how to see such heads
     if repo._activebookmark:
         _statusotherbook(ui, repo)
     else:
         _statusotherbranchheads(ui, repo)

tests/test-histedit-arguments.t

@@ -1,605 +1,605 b''
 #testcases abortcommand abortflag
 
 #if abortflag
   $ cat >> $HGRCPATH <<EOF
   > [alias]
   > abort = histedit --abort
   > EOF
 #endif
 
 Test argument handling and various data parsing
 ==================================================
 
 
 Enable extensions used by this test.
   $ cat >>$HGRCPATH <<EOF
   > [extensions]
   > histedit=
   > EOF
 
 Repo setup.
   $ hg init foo
   $ cd foo
   $ echo alpha >> alpha
   $ hg addr
   adding alpha
   $ hg ci -m one
   $ echo alpha >> alpha
   $ hg ci -m two
   $ echo alpha >> alpha
   $ hg ci -m three
   $ echo alpha >> alpha
   $ hg ci -m four
   $ echo alpha >> alpha
   $ hg ci -m five
 
   $ hg log --style compact --graph
   @  4[tip]   08d98a8350f3   1970-01-01 00:00 +0000   test
   |    five
   |
   o  3   c8e68270e35a   1970-01-01 00:00 +0000   test
   |    four
   |
   o  2   eb57da33312f   1970-01-01 00:00 +0000   test
   |    three
   |
   o  1   579e40513370   1970-01-01 00:00 +0000   test
   |    two
   |
   o  0   6058cbb6cfd7   1970-01-01 00:00 +0000   test
        one
   
 
 histedit --continue/--abort with no existing state
 --------------------------------------------------
 
   $ hg histedit --continue
   abort: no histedit in progress
   [20]
   $ hg abort
   abort: no histedit in progress (abortflag !)
   abort: no operation in progress (abortcommand !)
   [20]
 
 Run a dummy edit to make sure we get tip^^ correctly via revsingle.
 --------------------------------------------------------------------
 
   $ HGEDITOR=cat hg histedit "tip^^"
   pick eb57da33312f 2 three
   pick c8e68270e35a 3 four
   pick 08d98a8350f3 4 five
   
   # Edit history between eb57da33312f and 08d98a8350f3
   #
   # Commits are listed from least to most recent
   #
   # You can reorder changesets by reordering the lines
   #
   # Commands:
   #
   #  e, edit = use commit, but stop for amending
   #  m, mess = edit commit message without changing commit content
   #  p, pick = use commit
   #  b, base = checkout changeset and apply further changesets from there
   #  d, drop = remove commit from history
   #  f, fold = use commit, but combine it with the one above
   #  r, roll = like fold, but discard this commit's description and date
   #
 
 Run on a revision not ancestors of the current working directory.
 --------------------------------------------------------------------
 
   $ hg up 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg histedit -r 4
   abort: 08d98a8350f3 is not an ancestor of working directory
   [255]
   $ hg up --quiet
 
 
 Test that we pick the minimum of a revrange
 ---------------------------------------
 
   $ HGEDITOR=cat hg histedit '2::' --commands - << EOF
   > pick eb57da33312f 2 three
   > pick c8e68270e35a 3 four
   > pick 08d98a8350f3 4 five
   > EOF
   $ hg up --quiet
 
   $ HGEDITOR=cat hg histedit 'tip:2' --commands - << EOF
   > pick eb57da33312f 2 three
   > pick c8e68270e35a 3 four
   > pick 08d98a8350f3 4 five
   > EOF
   $ hg up --quiet
 
 Test config specified default
 -----------------------------
 
   $ HGEDITOR=cat hg histedit --config "histedit.defaultrev=only(.) - ::eb57da33312f" --commands - << EOF
   > pick c8e68270e35a 3 four
   > pick 08d98a8350f3 4 five
   > EOF
 
 Test invalid config default
 ---------------------------
 
   $ hg histedit --config "histedit.defaultrev="
   abort: config option histedit.defaultrev can't be empty
-  [255]
+  [30]
 
 Run on a revision not descendants of the initial parent
 --------------------------------------------------------------------
 
 Test the message shown for inconsistent histedit state, which may be
 created (and forgotten) by Mercurial earlier than 2.7. This emulates
 Mercurial earlier than 2.7 by renaming ".hg/histedit-state"
 temporarily.
 
   $ hg log -G -T '{rev} {shortest(node)} {desc}\n' -r 2::
   @  4 08d9 five
   |
   o  3 c8e6 four
   |
   o  2 eb57 three
   |
   ~
   $ HGEDITOR=cat hg histedit -r 4 --commands - << EOF
   > edit 08d98a8350f3 4 five
   > EOF
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   Editing (08d98a8350f3), you may commit or record as needed now.
   (hg histedit --continue to resume)
   [240]
 
   $ hg graft --continue
   abort: no graft in progress
   (continue: hg histedit --continue)
   [20]
 
   $ mv .hg/histedit-state .hg/histedit-state.back
   $ hg update --quiet --clean 2
   $ echo alpha >> alpha
   $ mv .hg/histedit-state.back .hg/histedit-state
 
   $ hg histedit --continue
   saved backup bundle to $TESTTMP/foo/.hg/strip-backup/08d98a8350f3-02594089-histedit.hg
   $ hg log -G -T '{rev} {shortest(node)} {desc}\n' -r 2::
   @  4 f5ed five
   |
   | o  3 c8e6 four
   |/
   o  2 eb57 three
   |
   ~
 
   $ hg unbundle -q $TESTTMP/foo/.hg/strip-backup/08d98a8350f3-02594089-histedit.hg
   $ hg strip -q -r f5ed --config extensions.strip=
   $ hg up -q 08d98a8350f3
 
 Test that missing revisions are detected
 ---------------------------------------
 
   $ HGEDITOR=cat hg histedit "tip^^" --commands - << EOF
   > pick eb57da33312f 2 three
   > pick 08d98a8350f3 4 five
   > EOF
   hg: parse error: missing rules for changeset c8e68270e35a
   (use "drop c8e68270e35a" to discard, see also: 'hg help -e histedit.config')
   [255]
 
 Test that extra revisions are detected
 ---------------------------------------
 
   $ HGEDITOR=cat hg histedit "tip^^" --commands - << EOF
   > pick 6058cbb6cfd7 0 one
   > pick c8e68270e35a 3 four
   > pick 08d98a8350f3 4 five
   > EOF
   hg: parse error: pick "6058cbb6cfd7" changeset was not a candidate
   (only use listed changesets)
   [255]
 
 Test malformed line
 ---------------------------------------
 
   $ HGEDITOR=cat hg histedit "tip^^" --commands - << EOF
   > pickeb57da33312f2three
   > pick c8e68270e35a 3 four
   > pick 08d98a8350f3 4 five
   > EOF
   hg: parse error: malformed line "pickeb57da33312f2three"
   [255]
 
 Test unknown changeset
 ---------------------------------------
 
   $ HGEDITOR=cat hg histedit "tip^^" --commands - << EOF
   > pick 0123456789ab 2 three
   > pick c8e68270e35a 3 four
   > pick 08d98a8350f3 4 five
   > EOF
   hg: parse error: unknown changeset 0123456789ab listed
   [255]
 
 Test unknown command
 ---------------------------------------
 
   $ HGEDITOR=cat hg histedit "tip^^" --commands - << EOF
   > coin eb57da33312f 2 three
   > pick c8e68270e35a 3 four
   > pick 08d98a8350f3 4 five
   > EOF
   hg: parse error: unknown action "coin"
   [255]
 
 Test duplicated changeset
 ---------------------------------------
 
 So one is missing and one appear twice.
 
   $ HGEDITOR=cat hg histedit "tip^^" --commands - << EOF
   > pick eb57da33312f 2 three
   > pick eb57da33312f 2 three
   > pick 08d98a8350f3 4 five
   > EOF
   hg: parse error: duplicated command for changeset eb57da33312f
   [255]
 
 Test bogus rev
 ---------------------------------------
 
   $ HGEDITOR=cat hg histedit "tip^^" --commands - << EOF
   > pick eb57da33312f 2 three
   > pick 0u98
   > pick 08d98a8350f3 4 five
   > EOF
   hg: parse error: invalid changeset 0u98
   [255]
 
 Test short version of command
 ---------------------------------------
 
 Note: we use varying amounts of white space between command name and changeset
 short hash. This tests issue3893.
 
   $ HGEDITOR=cat hg histedit "tip^^" --commands - << EOF
   > pick eb57da33312f 2 three
   > p    c8e68270e35a 3 four
   > f 08d98a8350f3 4 five
   > EOF
   four
   ***
   five
   
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: test
   HG: branch 'default'
   HG: changed alpha
   saved backup bundle to $TESTTMP/foo/.hg/strip-backup/c8e68270e35a-63d8b8d8-histedit.hg
 
   $ hg update -q 2
   $ echo x > x
   $ hg add x
   $ hg commit -m'x' x
   created new head
   $ hg histedit -r 'heads(all())'
   abort: The specified revisions must have exactly one common root
   [255]
 
 Test that trimming description using multi-byte characters
 --------------------------------------------------------------------
 
   $ "$PYTHON" <<EOF
   > fp = open('logfile', 'wb')
   > fp.write(b'12345678901234567890123456789012345678901234567890' +
   >          b'12345') # there are 5 more columns for 80 columns
   > 
   > # 2 x 4 = 8 columns, but 3 x 4 = 12 bytes
   > fp.write(u'\u3042\u3044\u3046\u3048'.encode('utf-8'))
   > 
   > fp.close()
   > EOF
   $ echo xx >> x
   $ hg --encoding utf-8 commit --logfile logfile
 
   $ HGEDITOR=cat hg --encoding utf-8 histedit tip
   pick 3d3ea1f3a10b 5 1234567890123456789012345678901234567890123456789012345\xe3\x81\x82... (esc)
   
   # Edit history between 3d3ea1f3a10b and 3d3ea1f3a10b
   #
   # Commits are listed from least to most recent
   #
   # You can reorder changesets by reordering the lines
   #
   # Commands:
   #
   #  e, edit = use commit, but stop for amending
   #  m, mess = edit commit message without changing commit content
   #  p, pick = use commit
   #  b, base = checkout changeset and apply further changesets from there
   #  d, drop = remove commit from history
   #  f, fold = use commit, but combine it with the one above
   #  r, roll = like fold, but discard this commit's description and date
   #
 
 Test --continue with --keep
 
   $ hg strip -q -r . --config extensions.strip=
   $ hg histedit '.^' -q --keep --commands - << EOF
   > edit eb57da33312f 2 three
   > pick f3cfcca30c44 4 x
   > EOF
   Editing (eb57da33312f), you may commit or record as needed now.
   (hg histedit --continue to resume)
   [240]
   $ echo edit >> alpha
   $ hg histedit -q --continue
   $ hg log -G -T '{rev}:{node|short} {desc}'
   @  6:8fda0c726bf2 x
   |
   o  5:63379946892c three
   |
   | o  4:f3cfcca30c44 x
   | |
   | | o  3:2a30f3cfee78 four
   | |/   ***
   | |    five
   | o  2:eb57da33312f three
   |/
   o  1:579e40513370 two
   |
   o  0:6058cbb6cfd7 one
   
 
 Test that abort fails gracefully on exception
 ----------------------------------------------
   $ hg histedit . -q --commands - << EOF
   > edit 8fda0c726bf2 6 x
   > EOF
   Editing (8fda0c726bf2), you may commit or record as needed now.
   (hg histedit --continue to resume)
   [240]
 Corrupt histedit state file
   $ sed 's/8fda0c726bf2/123456789012/' .hg/histedit-state > ../corrupt-histedit
   $ mv ../corrupt-histedit .hg/histedit-state
   $ hg abort
   warning: encountered an exception during histedit --abort; the repository may not have been completely cleaned up
   abort: $TESTTMP/foo/.hg/strip-backup/*-histedit.hg: $ENOENT$ (glob) (windows !)
   abort: $ENOENT$: '$TESTTMP/foo/.hg/strip-backup/*-histedit.hg' (glob) (no-windows !)
   [255]
 Histedit state has been exited
   $ hg summary -q
   parent: 5:63379946892c 
   commit: 1 added, 1 unknown (new branch head)
   update: 4 new changesets (update)
 
   $ cd ..
 
 Set up default base revision tests
 
   $ hg init defaultbase
   $ cd defaultbase
   $ touch foo
   $ hg -q commit -A -m root
   $ echo 1 > foo
   $ hg commit -m 'public 1'
   $ hg phase --force --public -r .
   $ echo 2 > foo
   $ hg commit -m 'draft after public'
   $ hg -q up -r 1
   $ echo 3 > foo
   $ hg commit -m 'head 1 public'
   created new head
   $ hg phase --force --public -r .
   $ echo 4 > foo
   $ hg commit -m 'head 1 draft 1'
   $ echo 5 > foo
   $ hg commit -m 'head 1 draft 2'
   $ hg -q up -r 2
   $ echo 6 > foo
   $ hg commit -m 'head 2 commit 1'
   $ echo 7 > foo
   $ hg commit -m 'head 2 commit 2'
   $ hg -q up -r 2
   $ echo 8 > foo
   $ hg commit -m 'head 3'
   created new head
   $ hg -q up -r 2
   $ echo 9 > foo
   $ hg commit -m 'head 4'
   created new head
   $ hg merge --tool :local -r 8
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg commit -m 'merge head 3 into head 4'
   $ echo 11 > foo
   $ hg commit -m 'commit 1 after merge'
   $ echo 12 > foo
   $ hg commit -m 'commit 2 after merge'
 
   $ hg log -G -T '{rev}:{node|short} {phase} {desc}\n'
   @  12:8cde254db839 draft commit 2 after merge
   |
   o  11:6f2f0241f119 draft commit 1 after merge
   |
   o    10:90506cc76b00 draft merge head 3 into head 4
   |\
   | o  9:f8607a373a97 draft head 4
   | |
   o |  8:0da92be05148 draft head 3
   |/
   | o  7:4c35cdf97d5e draft head 2 commit 2
   | |
   | o  6:931820154288 draft head 2 commit 1
   |/
   | o  5:8cdc02b9bc63 draft head 1 draft 2
   | |
   | o  4:463b8c0d2973 draft head 1 draft 1
   | |
   | o  3:23a0c4eefcbf public head 1 public
   | |
   o |  2:4117331c3abb draft draft after public
   |/
   o  1:4426d359ea59 public public 1
   |
   o  0:54136a8ddf32 public root
   
 
 Default base revision should stop at public changesets
 
   $ hg -q up 8cdc02b9bc63
   $ hg histedit --commands - <<EOF
   > pick 463b8c0d2973
   > pick 8cdc02b9bc63
   > EOF
 
 Default base revision should stop at branchpoint
 
   $ hg -q up 4c35cdf97d5e
   $ hg histedit --commands - <<EOF
   > pick 931820154288
   > pick 4c35cdf97d5e
   > EOF
 
 Default base revision should stop at merge commit
 
   $ hg -q up 8cde254db839
   $ hg histedit --commands - <<EOF
   > pick 6f2f0241f119
   > pick 8cde254db839
   > EOF
 
 commit --amend should abort if histedit is in progress
 (issue4800) and markers are not being created.
 Eventually, histedit could perhaps look at `source` extra,
 in which case this test should be revisited.
 
   $ hg -q up 8cde254db839
   $ hg histedit 6f2f0241f119 --commands - <<EOF
   > pick 8cde254db839
   > edit 6f2f0241f119
   > EOF
   merging foo
   warning: conflicts while merging foo! (edit, then use 'hg resolve --mark')
   Fix up the change (pick 8cde254db839)
   (hg histedit --continue to resume)
   [240]
   $ hg resolve -m --all
   (no more unresolved files)
   continue: hg histedit --continue
   $ hg histedit --cont
   merging foo
   warning: conflicts while merging foo! (edit, then use 'hg resolve --mark')
   Editing (6f2f0241f119), you may commit or record as needed now.
   (hg histedit --continue to resume)
   [240]
   $ hg resolve -m --all
   (no more unresolved files)
   continue: hg histedit --continue
   $ hg commit --amend -m 'reject this fold'
   abort: histedit in progress
   (use 'hg histedit --continue' or 'hg histedit --abort')
   [20]
 
 With markers enabled, histedit does not get confused, and
 amend should not be blocked by the ongoing histedit.
 
   $ cat >>$HGRCPATH <<EOF
   > [experimental]
   > evolution.createmarkers=True
   > evolution.allowunstable=True
   > EOF
   $ hg commit --amend -m 'allow this fold'
   $ hg histedit --continue
 
   $ cd ..
 
 Test autoverb feature
 
   $ hg init autoverb
   $ cd autoverb
   $ echo alpha >> alpha
   $ hg ci -qAm one
   $ echo alpha >> alpha
   $ hg ci -qm two
   $ echo beta >> beta
   $ hg ci -qAm "roll! one"
 
   $ hg log --style compact --graph
   @  2[tip]   4f34d0f8b5fa   1970-01-01 00:00 +0000   test
   |    roll! one
   |
   o  1   579e40513370   1970-01-01 00:00 +0000   test
   |    two
   |
   o  0   6058cbb6cfd7   1970-01-01 00:00 +0000   test
        one
   
 
 Check that 'roll' is selected by default
 
   $ HGEDITOR=cat hg histedit 0 --config experimental.histedit.autoverb=True
   pick 6058cbb6cfd7 0 one
   roll 4f34d0f8b5fa 2 roll! one
   pick 579e40513370 1 two
   
   # Edit history between 6058cbb6cfd7 and 4f34d0f8b5fa
   #
   # Commits are listed from least to most recent
   #
   # You can reorder changesets by reordering the lines
   #
   # Commands:
   #
   #  e, edit = use commit, but stop for amending
   #  m, mess = edit commit message without changing commit content
   #  p, pick = use commit
   #  b, base = checkout changeset and apply further changesets from there
   #  d, drop = remove commit from history
   #  f, fold = use commit, but combine it with the one above
   #  r, roll = like fold, but discard this commit's description and date
   #
 
   $ cd ..
 
 Check that histedit's commands accept revsets
   $ hg init bar
   $ cd bar
   $ echo w >> a
   $ hg ci -qAm "adds a"
   $ echo x >> b
   $ hg ci -qAm "adds b"
   $ echo y >> c
   $ hg ci -qAm "adds c"
   $ echo z >> d
   $ hg ci -qAm "adds d"
   $ hg log -G -T '{rev} {desc}\n'
   @  3 adds d
   |
   o  2 adds c
   |
   o  1 adds b
   |
   o  0 adds a
   
   $ HGEDITOR=cat hg histedit "2" --commands - << EOF
   > base -4 adds c
   > pick 2 adds c
   > pick tip adds d
   > EOF
   $ hg log -G -T '{rev} {desc}\n'
   @  5 adds d
   |
   o  4 adds c
   |
   | o  1 adds b
   |/
   o  0 adds a