# HG changeset patch
# User Gregory Szorc <gregory.szorc@gmail.com>
# Date 2017-07-02 05:38:42
# Node ID c5a07a3abe7dc4bb9a0bb9680a8a67f975a0081e
# Parent  439b4d005b4a2df2fa0edec6ce4de77df63c3134

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.

diff --git a/hgext/show.py b/hgext/show.py
--- a/hgext/show.py
+++ b/hgext/show.py
@@ -32,9 +32,11 @@ from mercurial.node import nullrev
 from mercurial import (
     cmdutil,
     commands,
+    destutil,
     error,
     formatter,
     graphmod,
+    phases,
     pycompat,
     registrar,
     revset,
@@ -171,6 +173,166 @@ def showbookmarks(ui, repo, fm):
         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')
diff --git a/mercurial/destutil.py b/mercurial/destutil.py
--- a/mercurial/destutil.py
+++ b/mercurial/destutil.py
@@ -354,6 +354,12 @@ def desthistedit(ui, repo):
 
     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()
diff --git a/mercurial/templates/map-cmdline.show b/mercurial/templates/map-cmdline.show
--- a/mercurial/templates/map-cmdline.show
+++ b/mercurial/templates/map-cmdline.show
@@ -6,6 +6,7 @@
 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))}'
 
diff --git a/tests/test-show-stack.t b/tests/test-show-stack.t
new file mode 100644
--- /dev/null
+++ b/tests/test-show-stack.t
@@ -0,0 +1,220 @@
+  $ 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
diff --git a/tests/test-show.t b/tests/test-show.t
--- a/tests/test-show.t
+++ b/tests/test-show.t
@@ -11,6 +11,7 @@ No arguments shows available views
   available views:
   
   bookmarks -- bookmarks and their associated changeset
+  stack -- current line of work
   work -- changesets that aren't finished
   
   abort: no view requested
@@ -40,6 +41,8 @@ No arguments shows 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)