# __init__.py - topic extension

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

"""support for topic branches

Topic branches are lightweight branches which disappear when changes are

finalized (move to the public phase).

Compared to bookmark, topic is reference carried by each changesets of the

series instead of just the single head revision.  Topic are quite similar to

the way named branch work, except they eventually fade away when the changeset

becomes part of the immutable history. Changeset can belong to both a topic and

a named branch, but as long as it is mutable, its topic identity will prevail.

As a result, default destination for 'update', 'merge', etc...  will take topic

into account. When a topic is active these operations will only consider other

changesets on that topic (and, in some occurrence, bare changeset on same

branch).  When no topic is active, changeset with topic will be ignored and

only bare one on the same branch will be taken in account.

There is currently two commands to be used with that extension: 'topics' and

'stack'.

The 'hg topics' command is used to set the current topic, change and list

existing one. 'hg topics --verbose' will list various information related to

each topic.

The 'stack' will show you information about the stack of commit belonging to

your current topic.

Topic is offering you aliases reference to changeset in your current topic

stack as 's#'. For example, 's1' refers to the root of your stack, 's2' to the

second commits, etc. The 'hg stack' command show these number. 's0' can be used

to refer to the parent of the topic root. Updating using `hg up s0` will keep

the topic active.

Push behavior will change a bit with topic. When pushing to a publishing

repository the changesets will turn public and the topic data on them will fade

away. The logic regarding pushing new heads will behave has before, ignore any

topic related data. When pushing to a non-publishing repository (supporting

topic), the head checking will be done taking topic data into account.

Push will complain about multiple heads on a branch if you push multiple heads

with no topic information on them (or multiple public heads). But pushing a new

topic will not requires any specific flag. However, pushing multiple heads on a

topic will be met with the usual warning.

The 'evolve' extension takes 'topic' into account. 'hg evolve --all'

will evolve all changesets in the active topic. In addition, by default. 'hg

next' and 'hg prev' will stick to the current topic.

Be aware that this extension is still an experiment, commands and other features

are likely to be change/adjusted/dropped over time as we refine the concept.

topic-mode

==========

The topic extension can be configured to ensure the user do not forget to add

a topic when committing a new topic::

    [experimental]

    # behavior when commit is made without an active topic

    topic-mode = ignore # do nothing special (default)

    topic-mode = warning # print a warning

    topic-mode = enforce # abort the commit (except for merge)

    topic-mode = enforce-all # abort the commit (even for merge)

    topic-mode = random # use a randomized generated topic (except for merge)

    topic-mode = random-all # use a randomized generated topic (even for merge)

Single head enforcing

=====================

The extensions come with an option to enforce that there is only one heads for

each name in the repository at any time.

::

    [experimental]

    enforce-single-head = yes

Publishing behavior

===================

Topic vanish when changeset move to the public phases. Moving to the public

phase usually happens on push, but it is possible to update that behavior. The

server needs to have specific config for this.

* everything pushed become public (the default)::

    [phase]

    publish = yes

* nothing push turned public::

    [phase]

    publish = no

* topic branches are not published, changeset without topic are::

    [phase]

    publish = no

    [experimental]

    topic.publish-bare-branch = yes

In addition, the topic extension adds a ``--publish`` flag on :hg:`push`. When

used, the pushed revisions are published if the push succeeds. It also applies

to common revisions selected by the push.

One can prevent any publishing to happens in a repository using::

    [experimental]

    topic.allow-publish = no

"""

from __future__ import absolute_import

import functools

import re

import time

import weakref

from mercurial.i18n import _

from mercurial import (

    bookmarks,

    changelog,

    cmdutil,

    commands,

    context,

    error,

    extensions,

    hg,

    localrepo,

    lock as lockmod,

    merge,

    namespaces,

    node,

    obsolete,

    patch,

    phases,

    pycompat,

    registrar,

    scmutil,

    templatefilters,

    templatekw,

    util,

)

from . import (

    common,

    compat,

    constants,

    destination,

    discovery,

    flow,

    randomname,

    revset as topicrevset,

    stack,

    topicmap,

)

cmdtable = {}

command = registrar.command(cmdtable)

colortable = {b'topic.active': b'green',

              b'topic.list.unstablecount': b'red',

              b'topic.list.headcount.multiple': b'yellow',

              b'topic.list.behindcount': b'cyan',

              b'topic.list.behinderror': b'red',

              b'stack.index': b'yellow',

              b'stack.index.base': b'none dim',

              b'stack.desc.base': b'none dim',

              b'stack.shortnode.base': b'none dim',

              b'stack.state.base': b'dim',

              b'stack.state.clean': b'green',

              b'stack.index.current': b'cyan',       # random pick

              b'stack.state.current': b'cyan bold',  # random pick

              b'stack.desc.current': b'cyan',        # random pick

              b'stack.shortnode.current': b'cyan',   # random pick

              b'stack.state.orphan': b'red',

              b'stack.state.content-divergent': b'red',

              b'stack.state.phase-divergent': b'red',

              b'stack.summary.behindcount': b'cyan',

              b'stack.summary.behinderror': b'red',

              b'stack.summary.headcount.multiple': b'yellow',

              # default color to help log output and thg

              # (first pick I could think off, update as needed

              b'log.topic': b'green_background',

              b'topic.active': b'green',

              }

testedwith = b'4.5.2 4.6.2 4.7 4.8 4.9 5.0 5.1'

minimumhgversion = b'4.5'

buglink = b'https://bz.mercurial-scm.org/'

if util.safehasattr(registrar, 'configitem'):

    from mercurial import configitems

    configtable = {}

    configitem = registrar.configitem(configtable)

    configitem(b'experimental', b'enforce-topic',

               default=False,

    )

    configitem(b'experimental', b'enforce-single-head',

               default=False,

    )

    configitem(b'experimental', b'topic-mode',

               default=None,

    )

    configitem(b'experimental', b'topic.publish-bare-branch',

               default=False,

    )

    configitem(b'experimental', b'topic.allow-publish',

               default=configitems.dynamicdefault,

    )

    configitem(b'_internal', b'keep-topic',

               default=False,

    )

    configitem(b'experimental', b'topic-mode.server',

               default=configitems.dynamicdefault,

    )

    def extsetup(ui):

        # register config that strictly belong to other code (thg, core, etc)

        #

        # To ensure all config items we used are registered, we register them if

        # nobody else did so far.

        from mercurial import configitems

        extraitem = functools.partial(configitems._register, ui._knownconfig)

        if (b'experimental' not in ui._knownconfig

                or not ui._knownconfig[b'experimental'].get(b'thg.displaynames')):

            extraitem(b'experimental', b'thg.displaynames',

                      default=None,

            )

        if (b'devel' not in ui._knownconfig

                or not ui._knownconfig[b'devel'].get(b'random')):

            extraitem(b'devel', b'randomseed',

                      default=None,

            )

# we need to do old style declaration for <= 4.5

templatekeyword = registrar.templatekeyword()

post45template = r'requires=' in templatekeyword.__doc__

def _contexttopic(self, force=False):

    if not (force or self.mutable()):

        return b''

    return self.extra().get(constants.extrakey, b'')

context.basectx.topic = _contexttopic

def _contexttopicidx(self):

    topic = self.topic()

    if not topic or self.obsolete():

        # XXX we might want to include s0 here,

        # however s0 is related to  'currenttopic' which has no place here.

        return None

    revlist = stack.stack(self._repo, topic=topic)

    try:

        return revlist.index(self.rev())

    except IndexError:

        # Lets move to the last ctx of the current topic

        return None

context.basectx.topicidx = _contexttopicidx

stackrev = re.compile(br'^s\d+$')

topicrev = re.compile(br'^t\d+$')

hastopicext = common.hastopicext

def _namemap(repo, name):

    revs = None

    if stackrev.match(name):

        idx = int(name[1:])

        tname = topic = repo.currenttopic

        if topic:

            ttype = b'topic'

            revs = list(stack.stack(repo, topic=topic))

        else:

            ttype = b'branch'

            tname = branch = repo[None].branch()

            revs = list(stack.stack(repo, branch=branch))

    elif topicrev.match(name):

        idx = int(name[1:])

        ttype = b'topic'

        tname = topic = repo.currenttopic

        if not tname:

            raise error.Abort(_(b'cannot resolve "%s": no active topic') % name)

        revs = list(stack.stack(repo, topic=topic))

    if revs is not None:

        try:

            r = revs[idx]

        except IndexError:

            if ttype == b'topic':

                msg = _(b'cannot resolve "%s": %s "%s" has only %d changesets')

            elif ttype == b'branch':

                msg = _(b'cannot resolve "%s": %s "%s" has only %d non-public changesets')

            raise error.Abort(msg % (name, ttype, tname, len(revs) - 1))

        # t0 or s0 can be None

        if r == -1 and idx == 0:

            msg = _(b'the %s "%s" has no %s')

            raise error.Abort(msg % (ttype, tname, name))

        return [repo[r].node()]

    if name not in repo.topics:

        return []

    node = repo.changelog.node

    return [node(rev) for rev in repo.revs(b'topic(%s)', name)]

def _nodemap(repo, node):

    ctx = repo[node]

    t = ctx.topic()

    if t and ctx.phase() > phases.public:

        return [t]

    return []

def uisetup(ui):

    destination.modsetup(ui)

    discovery.modsetup(ui)

    topicmap.modsetup(ui)

    setupimportexport(ui)

    extensions.afterloaded(b'rebase', _fixrebase)

    flow.installpushflag(ui)

    entry = extensions.wrapcommand(commands.table, b'commit', commitwrap)

    entry[1].append((b't', b'topic', b'',

                     _(b"use specified topic"), _(b'TOPIC')))

    entry = extensions.wrapcommand(commands.table, b'push', pushoutgoingwrap)

    entry[1].append((b't', b'topic', b'',

                     _(b"topic to push"), _(b'TOPIC')))

    entry = extensions.wrapcommand(commands.table, b'outgoing',

                                   pushoutgoingwrap)

    entry[1].append((b't', b'topic', b'',

                     _(b"topic to push"), _(b'TOPIC')))

    extensions.wrapfunction(cmdutil, 'buildcommittext', committextwrap)

    extensions.wrapfunction(merge, 'update', mergeupdatewrap)

    # We need to check whether t0 or b0 or s0 is passed to override the default update

    # behaviour of changing topic and I can't find a better way

    # to do that as scmutil.revsingle returns the rev number and hence we can't

    # plug into logic for this into mergemod.update().

    extensions.wrapcommand(commands.table, b'update', checkt0)

    try:

        evolve = extensions.find(b'evolve')

        extensions.wrapfunction(evolve.rewriteutil, "presplitupdate",

                                presplitupdatetopic)

    except (KeyError, AttributeError):

        pass

    cmdutil.summaryhooks.add(b'topic', summaryhook)

    if not post45template:

        templatekw.keywords[b'topic'] = topickw

        templatekw.keywords[b'topicidx'] = topicidxkw

    # Wrap workingctx extra to return the topic name

    extensions.wrapfunction(context.workingctx, '__init__', wrapinit)

    # Wrap changelog.add to drop empty topic

    extensions.wrapfunction(changelog.changelog, 'add', wrapadd)

def reposetup(ui, repo):

    if not isinstance(repo, localrepo.localrepository):

        return # this can be a peer in the ssh case (puzzling)

    repo = repo.unfiltered()

    if repo.ui.config(b'experimental', b'thg.displaynames') is None:

        repo.ui.setconfig(b'experimental', b'thg.displaynames', b'topics',

                          source=b'topic-extension')

    class topicrepo(repo.__class__):

        # attribute for other code to distinct between repo with topic and repo without

        hastopicext = True

        def _restrictcapabilities(self, caps):

            caps = super(topicrepo, self)._restrictcapabilities(caps)

            caps.add(b'topics')

            return caps

        def commit(self, *args, **kwargs):

            backup = self.ui.backupconfig(b'ui', b'allowemptycommit')

            try:

                if self.currenttopic != self[b'.'].topic():

                    # bypass the core "nothing changed" logic