stack: return a sorted smartrev by default

Most stack customers will display a list of revisions, sort it by default.

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

mercurial/destutil.py

@@ -1,415 +1,415
 # 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 _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('max(%ln)', successors).first()
             if bookmarks.isactivewdirparent(repo):
                 movemark = repo['.'].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
     activemark = None
     node, movemark = bookmarks.calculateupdate(repo.ui, repo, None)
     if node is not None:
         activemark = node
     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['.'].branch()
 
     if currentbranch in repo.branchmap():
         heads = repo.branchheads(currentbranch)
         if heads:
             node = repo.revs('max(.::(%ln))', heads).first()
         if bookmarks.isactivewdirparent(repo):
             movemark = repo['.'].node()
     elif currentbranch == '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('max(head() and not closed())').first()
     else:
         node = repo['.'].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, "any branch has at least one head"
         node = repo.revs('max(.::(%ln))', heads).first()
         assert node is not None, ("any revision has at least "
                                   "one descendant branch head")
         if bookmarks.isactivewdirparent(repo):
             movemark = repo['.'].node()
     else:
         # here, no "default" branch, and all branches are closed
         node = repo.lookup('tip')
         assert node is not None, "'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 = ['evolution', 'bookmark', 'branch', 'branchfallback']
 # mapping to ease extension overriding steps.
 destupdatestepmap = {'evolution': _destupdateobs,
                      'bookmark': _destupdatebook,
                      'branch': _destupdatebranch,
                      '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
     'toomanybookmarks':
         {'merge':
             (_("multiple matching bookmarks to merge -"
                " please merge with an explicit rev or bookmark"),
              _("run 'hg heads' to see all heads")),
          'rebase':
             (_("multiple matching bookmarks to rebase -"
                " please rebase to an explicit rev or bookmark"),
              _("run 'hg heads' to see all heads")),
         },
     # no other matching divergent bookmark
     'nootherbookmarks':
         {'merge':
             (_("no matching bookmark to merge - "
                "please merge with an explicit rev or bookmark"),
              _("run 'hg heads' to see all heads")),
          'rebase':
             (_("no matching bookmark to rebase - "
                "please rebase to an explicit rev or bookmark"),
              _("run 'hg heads' to see all heads")),
         },
     # branch have too many unbookmarked heads, no obvious destination
     'toomanyheads':
         {'merge':
             (_("branch '%s' has %d heads - please merge with an explicit rev"),
              _("run 'hg heads .' to see heads")),
          'rebase':
             (_("branch '%s' has %d heads - please rebase to an explicit rev"),
              _("run 'hg heads .' to see heads")),
         },
     # branch have no other unbookmarked heads
     'bookmarkedheads':
         {'merge':
             (_("heads are bookmarked - please merge with an explicit rev"),
              _("run 'hg heads' to see all heads")),
          'rebase':
             (_("heads are bookmarked - please rebase to an explicit rev"),
              _("run 'hg heads' to see all heads")),
         },
     # branch have just a single heads, but there is other branches
     'nootherbranchheads':
         {'merge':
             (_("branch '%s' has one head - please merge with an explicit rev"),
              _("run 'hg heads' to see all heads")),
          'rebase':
             (_("branch '%s' has one head - please rebase to an explicit rev"),
              _("run 'hg heads' to see all heads")),
         },
     # repository have a single head
     'nootherheads':
         {'merge':
             (_('nothing to merge'),
             None),
          'rebase':
             (_('nothing to rebase'),
             None),
         },
     # repository have a single head and we are not on it
     'nootherheadsbehind':
         {'merge':
             (_('nothing to merge'),
              _("use 'hg update' instead")),
          'rebase':
             (_('nothing to rebase'),
              _("use 'hg update' instead")),
         },
     # We are not on a head
     'notatheads':
         {'merge':
             (_('working directory not at a head revision'),
              _("use 'hg update' or merge with an explicit revision")),
          'rebase':
             (_('working directory not at a head revision'),
              _("use 'hg update' or rebase to an explicit revision"))
         },
     'emptysourceset':
         {'merge':
             (_('source set is empty'),
              None),
          'rebase':
             (_('source set is empty'),
              None),
         },
     'multiplebranchessourceset':
         {'merge':
             (_('source set is rooted in multiple branches'),
              None),
          'rebase':
             (_('rebaseset is rooted in multiple named branches'),
              _('specify an explicit destination with --dest')),
         },
     }
 
 def _destmergebook(repo, action='merge', sourceset=None, destspace=None):
     """find merge destination in the active bookmark case"""
     node = None
     bmheads = bookmarks.headsforactive(repo)
     curhead = repo[repo._activebookmark].node()
     if len(bmheads) == 2:
         if curhead == bmheads[0]:
             node = bmheads[1]
         else:
             node = bmheads[0]
     elif len(bmheads) > 2:
         msg, hint = msgdestmerge['toomanybookmarks'][action]
         raise error.ManyMergeDestAbort(msg, hint=hint)
     elif len(bmheads) <= 1:
         msg, hint = msgdestmerge['nootherbookmarks'][action]
         raise error.NoMergeDestAbort(msg, hint=hint)
     assert node is not None
     return node
 
 def _destmergebranch(repo, action='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['emptysourceset'][action]
         raise error.NoMergeDestAbort(msg, hint=hint)
     else:
         branch = None
         for ctx in repo.set('roots(%ld::%ld)', sourceset, sourceset):
             if branch is not None and ctx.branch() != branch:
                 msg, hint = msgdestmerge['multiplebranchessourceset'][action]
                 raise error.ManyMergeDestAbort(msg, hint=hint)
             branch = ctx.branch()
 
     bheads = repo.branchheads(branch)
     onhead = repo.revs('%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['nootherheadsbehind'][action]
         else:
             msg, hint = msgdestmerge['notatheads'][action]
         raise error.Abort(msg, hint=hint)
     # remove heads descendants of source from the set
     bheads = list(repo.revs('%ln - (%ld::)', bheads, sourceset))
     # filters out bookmarked heads
     nbhs = list(repo.revs('%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('%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['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['bookmarkedheads'][action]
         elif len(repo.heads()) > 1:
             msg, hint = msgdestmerge['nootherbranchheads'][action]
             msg %= branch
         elif not onhead:
             # if 'onheadcheck == False' (rebase case),
             # this was not caught in Case A.
             msg, hint = msgdestmerge['nootherheadsbehind'][action]
         else:
             msg, hint = msgdestmerge['nootherheads'][action]
         raise error.NoMergeDestAbort(msg, hint=hint)
     else:
         node = nbhs[0]
     assert node is not None
     return node
 
 def destmerge(repo, action='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('histedit', 'defaultrev')
 
     if default is None:
         revs = stack.getstack(repo)
     elif default:
         revs = scmutil.revrange(repo, [default])
 
     if revs:
         # The revset supplied by the user may not be in ascending order nor
         # take the first revision. So do this manually.
         revs.sort()
         return revs.first()
 
     return None
 
 def stackbase(ui, repo):
     revs = stack.getstack(repo)
-    return revs.last() if revs else None
+    return revs.first() if revs else None
 
 def _statusotherbook(ui, repo):
     bmheads = bookmarks.headsforactive(repo)
     curhead = repo[repo._activebookmark].node()
     if repo.revs('%n and parents()', curhead):
         # we are on the active bookmark
         bmheads = [b for b in bmheads if curhead != b]
         if bmheads:
             msg = _('%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('%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('%ln - parents()', heads)
         if repo['.'].closesbranch():
             ui.warn(_('no open descendant heads on branch "%s", '
                         'updating to a closed head\n') %
                       (currentbranch))
             if otherheads:
                 ui.warn(_("(committing will reopen the head, "
                             "use 'hg heads .' to see %i other heads)\n") %
                           (len(otherheads)))
             else:
                 ui.warn(_('(committing will reopen branch "%s")\n') %
                           (currentbranch))
         elif otherheads:
             curhead = repo['.']
             ui.status(_('updated to "%s: %s"\n') % (curhead,
                                     curhead.description().split('\n')[0]))
             ui.status(_('%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)

mercurial/stack.py

@@ -1,27 +1,29
 # stack.py - Mercurial functions for stack definition
 #
 #  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 . import (
     revsetlang,
     scmutil,
 )
 
 def getstack(repo, rev=None):
-    """return a smartrev of the stack containing either rev if it is not None
-    or the current working directory parent.
+    """return a sorted smartrev of the stack containing either rev if it is
+    not None or the current working directory parent.
 
     The stack will always contain all drafts changesets which are ancestors to
     the revision and are not merges.
     """
     if rev is None:
         rev = '.'
 
     revspec = 'reverse(only(%s) and not public() and not ::merge())'
     revset = revsetlang.formatspec(revspec, rev)
-    return scmutil.revrange(repo, [revset])
+    revisions = scmutil.revrange(repo, [revset])
+    revisions.sort()
+    return revisions

tests/test-stack.t

@@ -1,253 +1,253
 
 This test test the low-level definition of stack, agnostic from all formatting
 
 Initial setup
 
   $ cat << EOF >> $HGRCPATH
   > [ui]
   > logtemplate = {rev} {branch} {phase} {desc|firstline}\n
   > [extensions]
   > rebase=
   > [experimental]
   > evolution=createmarkers,exchange,allowunstable
   > EOF
 
   $ hg init main
   $ cd main
   $ hg branch other
   marked working directory as branch other
   (branches are permanent and global, did you want a bookmark?)
   $ echo aaa > aaa
   $ hg add aaa
   $ hg commit -m c_a
   $ echo aaa > bbb
   $ hg add bbb
   $ hg commit -m c_b
   $ hg branch foo
   marked working directory as branch foo
   $ echo aaa > ccc
   $ hg add ccc
   $ hg commit -m c_c
   $ echo aaa > ddd
   $ hg add ddd
   $ hg commit -m c_d
   $ echo aaa > eee
   $ hg add eee
   $ hg commit -m c_e
   $ echo aaa > fff
   $ hg add fff
   $ hg commit -m c_f
   $ hg log -G
   @  5 foo draft c_f
   |
   o  4 foo draft c_e
   |
   o  3 foo draft c_d
   |
   o  2 foo draft c_c
   |
   o  1 other draft c_b
   |
   o  0 other draft c_a
   
 
 Check that stack doesn't include public changesets
 --------------------------------------------------
 
   $ hg up other
   0 files updated, 0 files merged, 4 files removed, 0 files unresolved
   $ hg log -G -r "stack()"
   @  1 other draft c_b
   |
   o  0 other draft c_a
   
   $ hg phase --public 'branch("other")'
   $ hg log -G -r "stack()"
   $ hg up foo
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Simple test
 -----------
 
 'stack()' list all changeset in the branch
 
   $ hg branch
   foo
   $ hg log -G -r "stack()"
   @  5 foo draft c_f
   |
   o  4 foo draft c_e
   |
   o  3 foo draft c_d
   |
   o  2 foo draft c_c
   |
   ~
 
 Case with some of the branch unstable
 ------------------------------------
 
   $ hg up 3
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ echo bbb > ddd
   $ hg commit --amend
   2 new orphan changesets
   $ hg log -G
   @  6 foo draft c_d
   |
   | *  5 foo draft c_f
   | |
   | *  4 foo draft c_e
   | |
   | x  3 foo draft c_d
   |/
   o  2 foo draft c_c
   |
   o  1 other public c_b
   |
   o  0 other public c_a
   
   $ hg log -G -r "stack()"
   @  6 foo draft c_d
   |
   ~
   $ hg up -r "desc(c_e)"
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg log -G -r "stack()"
   @  4 foo draft c_e
   |
   x  3 foo draft c_d
   |
   ~
   $ hg up -r "desc(c_d)"
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
   $ hg log -G -r "stack()"
   @  6 foo draft c_d
   |
   ~
 
 Case with multiple topological heads
 ------------------------------------
 
 Make things linear again
 
   $ hg rebase -s 'desc(c_e)' -d 'desc(c_d) - obsolete()'
   rebasing 4:4f2a69f6d380 "c_e"
   rebasing 5:913c298d8b0a "c_f"
   $ hg log -G
   o  8 foo draft c_f
   |
   o  7 foo draft c_e
   |
   @  6 foo draft c_d
   |
   o  2 foo draft c_c
   |
   o  1 other public c_b
   |
   o  0 other public c_a
   
 
 Create the second branch
 
   $ hg up 'desc(c_d)'
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo aaa > ggg
   $ hg add ggg
   $ hg commit -m c_g
   created new head
   $ echo aaa > hhh
   $ hg add hhh
   $ hg commit -m c_h
   $ hg log -G
   @  10 foo draft c_h
   |
   o  9 foo draft c_g
   |
   | o  8 foo draft c_f
   | |
   | o  7 foo draft c_e
   |/
   o  6 foo draft c_d
   |
   o  2 foo draft c_c
   |
   o  1 other public c_b
   |
   o  0 other public c_a
   
 
 Test output
 
   $ hg log -G -r "stack(10)"
   @  10 foo draft c_h
   |
   o  9 foo draft c_g
   |
   ~
   $ hg log -G -r "stack(8)"
   o  8 foo draft c_f
   |
   o  7 foo draft c_e
   |
   ~
   $ hg log -G -r "stack(head())"
   @  10 foo draft c_h
   |
   o  9 foo draft c_g
   |
   ~
   o  8 foo draft c_f
   |
   o  7 foo draft c_e
   |
   ~
 Check the stack order
   $ hg log -r "first(stack())"
-  10 foo draft c_h
+  9 foo draft c_g
   $ hg log -r "first(stack(10))"
-  10 foo draft c_h
+  9 foo draft c_g
   $ hg log -r "first(stack(8))"
-  8 foo draft c_f
+  7 foo draft c_e
   $ hg log -r "first(stack(head()))"
-  8 foo draft c_f
+  7 foo draft c_e
 
 Case with multiple heads with unstability involved
 --------------------------------------------------
 
 We amend the message to make sure the display base pick the right changeset
 
   $ hg up 'desc(c_d)'
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ echo ccc > ddd
   $ hg commit --amend -m 'c_D'
   4 new orphan changesets
   $ hg rebase -d . -s 'desc(c_g)'
   rebasing 9:2ebb6e48ab8a "c_g"
   rebasing 10:634f38e27a1d "c_h"
   $ hg log -G
   o  13 foo draft c_h
   |
   o  12 foo draft c_g
   |
   @  11 foo draft c_D
   |
   | *  8 foo draft c_f
   | |
   | *  7 foo draft c_e
   | |
   | x  6 foo draft c_d
   |/
   o  2 foo draft c_c
   |
   o  1 other public c_b
   |
   o  0 other public c_a
   
 
 We should improve stack definition to also show 12 and 13 here
   $ hg log -G -r "stack()"
   @  11 foo draft c_D
   |
   ~