show: implement "stack" view

People often want to know what they are working on *now*. As part of
this, they also commonly want to know how that work is related to other
changesets in the repo so they can perform common actions like rebase,
histedit, and merge.

`hg show work` made headway into this space. However, it is geared
towards a complete repo view as opposed to just the current line of
work. If you have a lot of in-flight work or the repo has many heads,
the output can be overwhelming. The closest thing Mercurial has to
"show me the current thing I'm working on" that doesn't require custom
revsets is `hg qseries`. And this requires MQ, which completely changes
workflows and repository behavior and has horrible performance on large
repos. But as sub-optimal as MQ is, it does some things right, such as
expose a model of the repo that is easy for people to reason about.
This simplicity is why I think a lot of people prefer to use MQ, despite
its shortcomings.

One common development workflow is to author a series of linear
changesets, using bookmarks, branches, anonymous heads, or even topics
(3rd party extension). I'll call this a "stack." You periodically
rewrite history in place (using `hg histedit`) and reparent the stack
against newer changesets (using `hg rebase`). This workflow can be
difficult because there is no obvious way to quickly see the current
"stack" nor its relation to other changesets. Figuring out arguments to
`hg rebase` can be difficult and may require highlighting and pasting
multiple changeset nodes to construct a command.

The goal of this commit is to make stack based workflows simpler
by exposing a view of the current stack and its relationship to
other releant changesets, notably the parent of the base changeset
in the stack and newer heads that the stack could be rebased or merged
into.

Introduced is the `hg show stack` view. Essentially, it finds all
mutable changesets from the working directory revision in both
directions, stopping at a merge or branch point. This limits the
revisions to a DAG linear range.

The stack is rendered as a concise list of changesets. Alongside the
stack is a visualization of the DAG, similar to `hg log -G`.

Newer public heads from the branch point of the stack are rendered
above the stack. The presence of these heads helps people understand
the DAG model and the relationship between the stack and changes made
since the branch point of that stack. If the "rebase" command is
available, a `hg rebase` command is printed for each head so a user
can perform a simple copy and paste to perform a rebase.

This view is alpha quality. There are tons of TODOs documented
inline. But I think it is good enough for a first iteration.

tests/test-show-stack.t

@@ -0,0 +1,220 b''
+  $ cat >> $HGRCPATH << EOF
+  > [extensions]
+  > show =
+  > EOF
+
+  $ hg init repo0
+  $ cd repo0
+
+Empty repo / no checkout results in error
+
+  $ hg show stack
+  abort: stack view only available when there is a working directory
+  [255]
+
+Stack displays single draft changeset as root revision
+
+  $ echo 0 > foo
+  $ hg -q commit -A -m 'commit 0'
+  $ hg show stack
+    @  9f171 commit 0
+
+Stack displays multiple draft changesets
+
+  $ echo 1 > foo
+  $ hg commit -m 'commit 1'
+  $ echo 2 > foo
+  $ hg commit -m 'commit 2'
+  $ echo 3 > foo
+  $ hg commit -m 'commit 3'
+  $ echo 4 > foo
+  $ hg commit -m 'commit 4'
+  $ hg show stack
+    @  2737b commit 4
+    o  d1a69 commit 3
+    o  128c8 commit 2
+    o  181cc commit 1
+    o  9f171 commit 0
+
+Public parent of draft base is displayed, separated from stack
+
+  $ hg phase --public -r 0
+  $ hg show stack
+    @  2737b commit 4
+    o  d1a69 commit 3
+    o  128c8 commit 2
+    o  181cc commit 1
+   /   (stack base)
+  o  9f171 commit 0
+
+  $ hg phase --public -r 1
+  $ hg show stack
+    @  2737b commit 4
+    o  d1a69 commit 3
+    o  128c8 commit 2
+   /   (stack base)
+  o  181cc commit 1
+
+Draft descendants are shown
+
+  $ hg -q up 2
+  $ hg show stack
+    o  2737b commit 4
+    o  d1a69 commit 3
+    @  128c8 commit 2
+   /   (stack base)
+  o  181cc commit 1
+
+  $ hg -q up 3
+  $ hg show stack
+    o  2737b commit 4
+    @  d1a69 commit 3
+    o  128c8 commit 2
+   /   (stack base)
+  o  181cc commit 1
+
+working dir on public changeset should display special message
+
+  $ hg -q up 1
+  $ hg show stack
+  (empty stack; working directory is a published changeset)
+
+Branch point in descendants displayed at top of graph
+
+  $ hg -q up 3
+  $ echo b > foo
+  $ hg commit -m 'commit 5 (new dag branch)'
+  created new head
+  $ hg -q up 2
+  $ hg show stack
+   \ /  (multiple children)
+    |
+    o  d1a69 commit 3
+    @  128c8 commit 2
+   /   (stack base)
+  o  181cc commit 1
+
+  $ cd ..
+
+Base is stopped at merges
+
+  $ hg init merge-base
+  $ cd merge-base
+  $ echo 0 > foo
+  $ hg -q commit -A -m initial
+  $ echo h1 > foo
+  $ hg commit -m 'head 1'
+  $ hg -q up 0
+  $ echo h2 > foo
+  $ hg -q commit -m 'head 2'
+  $ hg phase --public -r 0:tip
+  $ hg -q up 1
+  $ hg merge -t :local 2
+  0 files updated, 1 files merged, 0 files removed, 0 files unresolved
+  (branch merge, don't forget to commit)
+  $ hg commit -m 'merge heads'
+
+TODO doesn't yet handle case where wdir is a draft merge
+
+  $ hg show stack
+    @  8ee90 merge heads
+   /   (stack base)
+  o  59478 head 1
+
+  $ echo d1 > foo
+  $ hg commit -m 'draft 1'
+  $ echo d2 > foo
+  $ hg commit -m 'draft 2'
+
+  $ hg show stack
+    @  430d5 draft 2
+    o  787b1 draft 1
+   /   (stack base)
+  o  8ee90 merge heads
+
+  $ cd ..
+
+Now move on to stacks when there are more commits after the base branchpoint
+
+  $ hg init public-rebase
+  $ cd public-rebase
+  $ echo 0 > foo
+  $ hg -q commit -A -m 'base'
+  $ hg phase --public -r .
+  $ echo d1 > foo
+  $ hg commit -m 'draft 1'
+  $ echo d2 > foo
+  $ hg commit -m 'draft 2'
+  $ hg -q up 0
+  $ echo 1 > foo
+  $ hg commit -m 'new 1'
+  created new head
+  $ echo 2 > foo
+  $ hg commit -m 'new 2'
+  $ hg -q up 2
+
+Newer draft heads don't impact output
+
+  $ hg show stack
+    @  eaffc draft 2
+    o  2b218 draft 1
+   /   (stack base)
+  o  b66bb base
+
+Newer public heads are rendered
+
+  $ hg phase --public -r '::tip'
+
+  $ hg show stack
+    o  baa4b new 2
+   /    (2 commits ahead)
+  :
+  :    (stack head)
+  : @  eaffc draft 2
+  : o  2b218 draft 1
+  :/   (stack base)
+  o  b66bb base
+
+If rebase is available, we show a hint how to rebase to that head
+
+  $ hg --config extensions.rebase= show stack
+    o  baa4b new 2
+   /    (2 commits ahead; hg rebase --source 2b218 --dest baa4b)
+  :
+  :    (stack head)
+  : @  eaffc draft 2
+  : o  2b218 draft 1
+  :/   (stack base)
+  o  b66bb base
+
+Similar tests but for multiple heads
+
+  $ hg -q up 0
+  $ echo h2 > foo
+  $ hg -q commit -m 'new head 2'
+  $ hg phase --public -r .
+  $ hg -q up 2
+
+  $ hg show stack
+    o  baa4b new 2
+   /    (2 commits ahead)
+  : o  9a848 new head 2
+  :/    (1 commits ahead)
+  :
+  :    (stack head)
+  : @  eaffc draft 2
+  : o  2b218 draft 1
+  :/   (stack base)
+  o  b66bb base
+
+  $ hg --config extensions.rebase= show stack
+    o  baa4b new 2
+   /    (2 commits ahead; hg rebase --source 2b218 --dest baa4b)
+  : o  9a848 new head 2
+  :/    (1 commits ahead; hg rebase --source 2b218 --dest 9a848)
+  :
+  :    (stack head)
+  : @  eaffc draft 2
+  : o  2b218 draft 1
+  :/   (stack base)
+  o  b66bb base

hgext/show.py

@@ -1,270 +1,432 b''
 # show.py - Extension implementing `hg show`
 #
 # Copyright 2017 Gregory Szorc <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 """unified command to show various repository information (EXPERIMENTAL)
 
 This extension provides the :hg:`show` command, which provides a central
 command for displaying commonly-accessed repository data and views of that
 data.
 
 The following config options can influence operation.
 
 ``commands``
 ------------
 
 ``show.aliasprefix``
    List of strings that will register aliases for views. e.g. ``s`` will
    effectively set config options ``alias.s<view> = show <view>`` for all
    views. i.e. `hg swork` would execute `hg show work`.
 
    Aliases that would conflict with existing registrations will not be
    performed.
 """
 
 from __future__ import absolute_import
 
 from mercurial.i18n import _
 from mercurial.node import nullrev
 from mercurial import (
     cmdutil,
     commands,
+    destutil,
     error,
     formatter,
     graphmod,
+    phases,
     pycompat,
     registrar,
     revset,
     revsetlang,
 )
 
 # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
 testedwith = 'ships-with-hg-core'
 
 cmdtable = {}
 command = registrar.command(cmdtable)
 revsetpredicate = registrar.revsetpredicate()
 
 class showcmdfunc(registrar._funcregistrarbase):
     """Register a function to be invoked for an `hg show <thing>`."""
 
     # Used by _formatdoc().
     _docformat = '%s -- %s'
 
     def _extrasetup(self, name, func, fmtopic=None, csettopic=None):
         """Called with decorator arguments to register a show view.
 
         ``name`` is the sub-command name.
 
         ``func`` is the function being decorated.
 
         ``fmtopic`` is the topic in the style that will be rendered for
         this view.
 
         ``csettopic`` is the topic in the style to be used for a changeset
         printer.
 
         If ``fmtopic`` is specified, the view function will receive a
         formatter instance. If ``csettopic`` is specified, the view
         function will receive a changeset printer.
         """
         func._fmtopic = fmtopic
         func._csettopic = csettopic
 
 showview = showcmdfunc()
 
 @command('show', [
     # TODO: Switch this template flag to use cmdutil.formatteropts if
     # 'hg show' becomes stable before --template/-T is stable. For now,
     # we are putting it here without the '(EXPERIMENTAL)' flag because it
     # is an important part of the 'hg show' user experience and the entire
     # 'hg show' experience is experimental.
     ('T', 'template', '', ('display with template'), _('TEMPLATE')),
     ], _('VIEW'))
 def show(ui, repo, view=None, template=None):
     """show various repository information
 
     A requested view of repository data is displayed.
 
     If no view is requested, the list of available views is shown and the
     command aborts.
 
     .. note::
 
        There are no backwards compatibility guarantees for the output of this
        command. Output may change in any future Mercurial release.
 
        Consumers wanting stable command output should specify a template via
        ``-T/--template``.
 
     List of available views:
     """
     if ui.plain() and not template:
         hint = _('invoke with -T/--template to control output format')
         raise error.Abort(_('must specify a template in plain mode'), hint=hint)
 
     views = showview._table
 
     if not view:
         ui.pager('show')
         # TODO consider using formatter here so available views can be
         # rendered to custom format.
         ui.write(_('available views:\n'))
         ui.write('\n')
 
         for name, func in sorted(views.items()):
             ui.write(('%s\n') % func.__doc__)
 
         ui.write('\n')
         raise error.Abort(_('no view requested'),
                           hint=_('use "hg show VIEW" to choose a view'))
 
     # TODO use same logic as dispatch to perform prefix matching.
     if view not in views:
         raise error.Abort(_('unknown view: %s') % view,
                           hint=_('run "hg show" to see available views'))
 
     template = template or 'show'
 
     fn = views[view]
     ui.pager('show')
 
     if fn._fmtopic:
         fmtopic = 'show%s' % fn._fmtopic
         with ui.formatter(fmtopic, {'template': template}) as fm:
             return fn(ui, repo, fm)
     elif fn._csettopic:
         ref = 'show%s' % fn._csettopic
         spec = formatter.lookuptemplate(ui, ref, template)
         displayer = cmdutil.changeset_templater(ui, repo, spec, buffered=True)
         return fn(ui, repo, displayer)
     else:
         return fn(ui, repo)
 
 @showview('bookmarks', fmtopic='bookmarks')
 def showbookmarks(ui, repo, fm):
     """bookmarks and their associated changeset"""
     marks = repo._bookmarks
     if not len(marks):
         # This is a bit hacky. Ideally, templates would have a way to
         # specify an empty output, but we shouldn't corrupt JSON while
         # waiting for this functionality.
         if not isinstance(fm, formatter.jsonformatter):
             ui.write(_('(no bookmarks set)\n'))
         return
 
     active = repo._activebookmark
     longestname = max(len(b) for b in marks)
     # TODO consider exposing longest shortest(node).
 
     for bm, node in sorted(marks.items()):
         fm.startitem()
         fm.context(ctx=repo[node])
         fm.write('bookmark', '%s', bm)
         fm.write('node', fm.hexfunc(node), fm.hexfunc(node))
         fm.data(active=bm == active,
                 longestbookmarklen=longestname)
 
+@showview('stack', csettopic='stack')
+def showstack(ui, repo, displayer):
+    """current line of work"""
+    wdirctx = repo['.']
+    if wdirctx.rev() == nullrev:
+        raise error.Abort(_('stack view only available when there is a '
+                            'working directory'))
+
+    if wdirctx.phase() == phases.public:
+        ui.write(_('(empty stack; working directory is a published '
+                   'changeset)\n'))
+        return
+
+    # TODO extract "find stack" into a function to facilitate
+    # customization and reuse.
+
+    baserev = destutil.stackbase(ui, repo)
+    basectx = None
+
+    if baserev is None:
+        baserev = wdirctx.rev()
+        stackrevs = {wdirctx.rev()}
+    else:
+        stackrevs = set(repo.revs('%d::.', baserev))
+
+    ctx = repo[baserev]
+    if ctx.p1().rev() != nullrev:
+        basectx = ctx.p1()
+
+    # And relevant descendants.
+    branchpointattip = False
+    cl = repo.changelog
+
+    for rev in cl.descendants([wdirctx.rev()]):
+        ctx = repo[rev]
+
+        # Will only happen if . is public.
+        if ctx.phase() == phases.public:
+            break
+
+        stackrevs.add(ctx.rev())
+
+        if len(ctx.children()) > 1:
+            branchpointattip = True
+            break
+
+    stackrevs = list(reversed(sorted(stackrevs)))
+
+    # Find likely target heads for the current stack. These are likely
+    # merge or rebase targets.
+    if basectx:
+        # TODO make this customizable?
+        newheads = set(repo.revs('heads(%d::) - %ld - not public()',
+                                 basectx.rev(), stackrevs))
+    else:
+        newheads = set()
+
+    try:
+        cmdutil.findcmd('rebase', commands.table)
+        haverebase = True
+    except error.UnknownCommand:
+        haverebase = False
+
+    # TODO use templating.
+    # TODO consider using graphmod. But it may not be necessary given
+    # our simplicity and the customizations required.
+    # TODO use proper graph symbols from graphmod
+
+    shortesttmpl = formatter.maketemplater(ui, '{shortest(node, 5)}')
+    def shortest(ctx):
+        return shortesttmpl.render({'ctx': ctx, 'node': ctx.hex()})
+
+    # We write out new heads to aid in DAG awareness and to help with decision
+    # making on how the stack should be reconciled with commits made since the
+    # branch point.
+    if newheads:
+        # Calculate distance from base so we can render the count and so we can
+        # sort display order by commit distance.
+        revdistance = {}
+        for head in newheads:
+            # There is some redundancy in DAG traversal here and therefore
+            # room to optimize.
+            ancestors = cl.ancestors([head], stoprev=basectx.rev())
+            revdistance[head] = len(list(ancestors))
+
+        sourcectx = repo[stackrevs[-1]]
+
+        sortedheads = sorted(newheads, key=lambda x: revdistance[x],
+                             reverse=True)
+
+        for i, rev in enumerate(sortedheads):
+            ctx = repo[rev]
+
+            if i:
+                ui.write(': ')
+            else:
+                ui.write('  ')
+
+            ui.write(('o  '))
+            displayer.show(ctx)
+            displayer.flush(ctx)
+            ui.write('\n')
+
+            if i:
+                ui.write(':/')
+            else:
+                ui.write(' /')
+
+            ui.write('    (')
+            ui.write(_('%d commits ahead') % revdistance[rev],
+                     label='stack.commitdistance')
+
+            if haverebase:
+                # TODO may be able to omit --source in some scenarios
+                ui.write('; ')
+                ui.write(('hg rebase --source %s --dest %s' % (
+                         shortest(sourcectx), shortest(ctx))),
+                         label='stack.rebasehint')
+
+            ui.write(')\n')
+
+        ui.write(':\n:    ')
+        ui.write(_('(stack head)\n'), label='stack.label')
+
+    if branchpointattip:
+        ui.write(' \\ /  ')
+        ui.write(_('(multiple children)\n'), label='stack.label')
+        ui.write('  |\n')
+
+    for rev in stackrevs:
+        ctx = repo[rev]
+        symbol = '@' if rev == wdirctx.rev() else 'o'
+
+        if newheads:
+            ui.write(': ')
+        else:
+            ui.write('  ')
+
+        ui.write(symbol, '  ')
+        displayer.show(ctx)
+        displayer.flush(ctx)
+        ui.write('\n')
+
+    # TODO display histedit hint?
+
+    if basectx:
+        # Vertically and horizontally separate stack base from parent
+        # to reinforce stack boundary.
+        if newheads:
+            ui.write(':/   ')
+        else:
+            ui.write(' /   ')
+
+        ui.write(_('(stack base)'), '\n', label='stack.label')
+        ui.write(('o  '))
+
+        displayer.show(basectx)
+        displayer.flush(basectx)
+        ui.write('\n')
+
 @revsetpredicate('_underway([commitage[, headage]])')
 def underwayrevset(repo, subset, x):
     args = revset.getargsdict(x, 'underway', 'commitage headage')
     if 'commitage' not in args:
         args['commitage'] = None
     if 'headage' not in args:
         args['headage'] = None
 
     # We assume callers of this revset add a topographical sort on the
     # result. This means there is no benefit to making the revset lazy
     # since the topographical sort needs to consume all revs.
     #
     # With this in mind, we build up the set manually instead of constructing
     # a complex revset. This enables faster execution.
 
     # Mutable changesets (non-public) are the most important changesets
     # to return. ``not public()`` will also pull in obsolete changesets if
     # there is a non-obsolete changeset with obsolete ancestors. This is
     # why we exclude obsolete changesets from this query.
     rs = 'not public() and not obsolete()'
     rsargs = []
     if args['commitage']:
         rs += ' and date(%s)'
         rsargs.append(revsetlang.getstring(args['commitage'],
                                            _('commitage requires a string')))
 
     mutable = repo.revs(rs, *rsargs)
     relevant = revset.baseset(mutable)
 
     # Add parents of mutable changesets to provide context.
     relevant += repo.revs('parents(%ld)', mutable)
 
     # We also pull in (public) heads if they a) aren't closing a branch
     # b) are recent.
     rs = 'head() and not closed()'
     rsargs = []
     if args['headage']:
         rs += ' and date(%s)'
         rsargs.append(revsetlang.getstring(args['headage'],
                                            _('headage requires a string')))
 
     relevant += repo.revs(rs, *rsargs)
 
     # Add working directory parent.
     wdirrev = repo['.'].rev()
     if wdirrev != nullrev:
         relevant += revset.baseset({wdirrev})
 
     return subset & relevant
 
 @showview('work', csettopic='work')
 def showwork(ui, repo, displayer):
     """changesets that aren't finished"""
     # TODO support date-based limiting when calling revset.
     revs = repo.revs('sort(_underway(), topo)')
 
     revdag = graphmod.dagwalker(repo, revs)
 
     ui.setconfig('experimental', 'graphshorten', True)
     cmdutil.displaygraph(ui, repo, revdag, displayer, graphmod.asciiedges)
 
 def extsetup(ui):
     # Alias `hg <prefix><view>` to `hg show <view>`.
     for prefix in ui.configlist('commands', 'show.aliasprefix'):
         for view in showview._table:
             name = '%s%s' % (prefix, view)
 
             choice, allcommands = cmdutil.findpossible(name, commands.table,
                                                        strict=True)
 
             # This alias is already a command name. Don't set it.
             if name in choice:
                 continue
 
             # Same for aliases.
             if ui.config('alias', name):
                 continue
 
             ui.setconfig('alias', name, 'show %s' % view, source='show')
 
 # Adjust the docstring of the show command so it shows all registered views.
 # This is a bit hacky because it runs at the end of module load. When moved
 # into core or when another extension wants to provide a view, we'll need
 # to do this more robustly.
 # TODO make this more robust.
 def _updatedocstring():
     longest = max(map(len, showview._table.keys()))
     entries = []
     for key in sorted(showview._table.keys()):
         entries.append(pycompat.sysstr('    %s   %s' % (
             key.ljust(longest), showview._table[key]._origdoc)))
 
     cmdtable['show'][0].__doc__ = pycompat.sysstr('%s\n\n%s\n    ') % (
         cmdtable['show'][0].__doc__.rstrip(),
         pycompat.sysstr('\n\n').join(entries))
 
 _updatedocstring()

mercurial/destutil.py

@@ -1,408 +1,414 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,
 )
 
 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()
 
 histeditdefaultrevset = 'reverse(only(.) and not public() and not ::merge())'
 
 def desthistedit(ui, repo):
     """Default base revision to edit for `hg histedit`."""
     default = ui.config('histedit', 'defaultrev', histeditdefaultrevset)
     if 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):
+    # The histedit default base stops at public changesets, branchpoints,
+    # and merges, which is exactly what we want for a stack.
+    revs = scmutil.revrange(repo, [histeditdefaultrevset])
+    return revs.last() 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/templates/map-cmdline.show

@@ -1,18 +1,19 b''
 # TODO there are a few deficiencies in this file:
 # * The "namespace" of the labels needs to be worked out. We currently
 #   piggyback on existing values so color works.
 # * Obsolescence isn't considered for node labels. See _cset_labels in
 #   map-cmdline.default.
 showbookmarks = '{if(active, "*", " ")} {pad(bookmark, longestbookmarklen + 4)}{shortest(node, 5)}\n'
 
 showwork = '{cset_shortnode}{namespaces % cset_namespace} {cset_shortdesc}'
+showstack = '{showwork}'
 
 cset_shortnode = '{label("log.changeset changeset.{phase}", shortest(node, 5))}'
 
 # Treat branch and tags specially so we don't display "default" or "tip"
 cset_namespace = '{ifeq(namespace, "branches", names_branches, ifeq(namespace, "tags", names_tags, names_others))}'
 names_branches = '{ifeq(branch, "default", "", " ({label('log.{colorname}', branch)})")}'
 names_tags = '{if(names % "{ifeq(name, 'tip', '', name)}", " ({label('log.{colorname}', join(names % "{ifeq(name, 'tip', '', name)}", ' '))})")}'
 names_others = '{if(names, " ({label('log.{colorname}', join(names, ' '))})")}'
 
 cset_shortdesc = '{label("log.description", desc|firstline)}'

tests/test-show.t

@@ -1,168 +1,171 b''
   $ cat >> $HGRCPATH << EOF
   > [extensions]
   > show =
   > EOF
 
 No arguments shows available views
 
   $ hg init empty
   $ cd empty
   $ hg show
   available views:
   
   bookmarks -- bookmarks and their associated changeset
+  stack -- current line of work
   work -- changesets that aren't finished
   
   abort: no view requested
   (use "hg show VIEW" to choose a view)
   [255]
 
 `hg help show` prints available views
 
   $ hg help show
   hg show VIEW
   
   show various repository information
   
       A requested view of repository data is displayed.
   
       If no view is requested, the list of available views is shown and the
       command aborts.
   
       Note:
          There are no backwards compatibility guarantees for the output of this
          command. Output may change in any future Mercurial release.
   
          Consumers wanting stable command output should specify a template via
          "-T/--template".
   
       List of available views:
   
       bookmarks   bookmarks and their associated changeset
   
+      stack       current line of work
+  
       work        changesets that aren't finished
   
   (use 'hg help -e show' to show help for the show extension)
   
   options:
   
    -T --template TEMPLATE display with template
   
   (some details hidden, use --verbose to show complete help)
 
 Unknown view prints error
 
   $ hg show badview
   abort: unknown view: badview
   (run "hg show" to see available views)
   [255]
 
 HGPLAIN results in abort
 
   $ HGPLAIN=1 hg show bookmarks
   abort: must specify a template in plain mode
   (invoke with -T/--template to control output format)
   [255]
 
 But not if a template is specified
 
   $ HGPLAIN=1 hg show bookmarks -T '{bookmark}\n'
   (no bookmarks set)
 
   $ cd ..
 
 bookmarks view with no bookmarks prints empty message
 
   $ hg init books
   $ cd books
   $ touch f0
   $ hg -q commit -A -m initial
 
   $ hg show bookmarks
   (no bookmarks set)
 
 bookmarks view shows bookmarks in an aligned table
 
   $ echo book1 > f0
   $ hg commit -m 'commit for book1'
   $ echo book2 > f0
   $ hg commit -m 'commit for book2'
 
   $ hg bookmark -r 1 book1
   $ hg bookmark a-longer-bookmark
 
   $ hg show bookmarks
   * a-longer-bookmark    7b570
     book1                b757f
 
 A custom bookmarks template works
 
   $ hg show bookmarks -T '{node} {bookmark} {active}\n'
   7b5709ab64cbc34da9b4367b64afff47f2c4ee83 a-longer-bookmark True
   b757f780b8ffd71267c6ccb32e0882d9d32a8cc0 book1 False
 
 bookmarks JSON works
 
   $ hg show bookmarks -T json
   [
    {
     "active": true,
     "bookmark": "a-longer-bookmark",
     "longestbookmarklen": 17,
     "node": "7b5709ab64cbc34da9b4367b64afff47f2c4ee83"
    },
    {
     "active": false,
     "bookmark": "book1",
     "longestbookmarklen": 17,
     "node": "b757f780b8ffd71267c6ccb32e0882d9d32a8cc0"
    }
   ]
 
 JSON works with no bookmarks
 
   $ hg book -d a-longer-bookmark
   $ hg book -d book1
   $ hg show bookmarks -T json
   [
   ]
 
 commands.show.aliasprefix aliases values to `show <view>`
 
   $ hg --config commands.show.aliasprefix=s sbookmarks
   (no bookmarks set)
 
   $ hg --config commands.show.aliasprefix=sh shwork
   @  7b570 commit for book2
   o  b757f commit for book1
   o  ba592 initial
 
   $ hg --config commands.show.aliasprefix='s sh' swork
   @  7b570 commit for book2
   o  b757f commit for book1
   o  ba592 initial
 
   $ hg --config commands.show.aliasprefix='s sh' shwork
   @  7b570 commit for book2
   o  b757f commit for book1
   o  ba592 initial
 
 The aliases don't appear in `hg config`
 
   $ hg --config commands.show.aliasprefix=s config alias
   [1]
 
 Doesn't overwrite existing alias
 
   $ hg --config alias.swork='log -r .' --config commands.show.aliasprefix=s swork
   changeset:   2:7b5709ab64cb
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit for book2
   
 
   $ hg --config alias.swork='log -r .' --config commands.show.aliasprefix=s config alias
   alias.swork=log -r .
 
   $ cd ..