# __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 eventualy 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 occurence, 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 't#'. For example, 't1' refers to the root of your stack, 't2' to the

second commits, etc. The 'hg stack' command show these number.

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.

"""

from __future__ import absolute_import

import re

import time

from mercurial.i18n import _

from mercurial import (

    cmdutil,

    commands,

    context,

    error,

    extensions,

    hg,

    localrepo,

    lock,

    merge,

    namespaces,

    node,

    obsolete,

    obsutil,

    patch,

    phases,

    registrar,

    templatefilters,

    util,

)

from . import (

    constants,

    revset as topicrevset,

    destination,

    stack,

    topicmap,

    discovery,

)

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

    commandfunc = registrar.command

else: # compat with hg < 4.3

    commandfunc = cmdutil.command

cmdtable = {}

command = commandfunc(cmdtable)

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

              'topic.list.troubledcount': 'red',

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

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

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

              'topic.stack.index': 'yellow',

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

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

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

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

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

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

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

              'topic.stack.state.unstable': 'red',

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

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

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

              # default color to help log output and thg

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

              'log.topic': 'green_background',

              'topic.active': 'green',

             }

version = '0.2.0.dev'

testedwith = '4.0.2 4.1.3 4.2.1'

minimumhgversion = '4.0'

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

def _contexttopic(self, force=False):

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

        return ''

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

context.basectx.topic = _contexttopic

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

branchrev = re.compile(r'^b\d+$')

def _namemap(repo, name):

    revs = None

    if topicrev.match(name):

        idx = int(name[1:])

        ttype = 'topic'

        tname = topic = repo.currenttopic

        if not tname:

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

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

    elif branchrev.match(name):

        ttype = 'branch'

        idx = int(name[1:])

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

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

    if revs is not None:

        try:

            r = revs[idx]

        except IndexError:

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

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

        # b0 or t0 can be None

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

            msg = _('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('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)

    topicrevset.modsetup(ui)

    discovery.modsetup(ui)

    topicmap.modsetup(ui)

    setupimportexport(ui)

    extensions.afterloaded('rebase', _fixrebase)

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

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

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

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

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

    # We need to check whether t0 or b0 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, 'update', checkt0)

    try:

        evolve = extensions.find('evolve')

        extensions.wrapfunction(evolve, "presplitupdate", presplitupdatetopic)

    except (KeyError, AttributeError):

        pass

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

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('experimental', 'thg.displaynames', None) is None:

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

                          source='topic-extension')

    class topicrepo(repo.__class__):

        def _restrictcapabilities(self, caps):

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

            caps.add('topics')

            return caps

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

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

            try:

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

                    # bypass the core "nothing changed" logic

                    self.ui.setconfig('ui', 'allowemptycommit', True)

                return super(topicrepo, self).commit(*args, **kwargs)

            finally:

                self.ui.restoreconfig(backup)

        def commitctx(self, ctx, error=None):

            topicfilter = topicmap.topicfilter(self.filtername)

            if topicfilter != self.filtername:

                other = repo.filtered(topicmap.topicfilter(repo.filtername))

                other.commitctx(ctx, error=error)

            if isinstance(ctx, context.workingcommitctx):

                current = self.currenttopic

                if current:

                    ctx.extra()[constants.extrakey] = current

            if (isinstance(ctx, context.memctx) and

                ctx.extra().get('amend_source') and

                ctx.topic() and

                not self.currenttopic):

                # we are amending and need to remove a topic

                del ctx.extra()[constants.extrakey]

            return super(topicrepo, self).commitctx(ctx, error=error)

        @property

        def topics(self):

            if self._topics is not None:

                return self._topics

            topics = set(['', self.currenttopic])

            for c in self.set('not public()'):

                topics.add(c.topic())

            topics.remove('')

            self._topics = topics

            return topics

        @property

        def currenttopic(self):

            return self.vfs.tryread('topic')

        # overwritten at the instance level by topicmap.py

        _autobranchmaptopic = True

        def branchmap(self, topic=None):

            if topic is None:

                topic = getattr(repo, '_autobranchmaptopic', False)

            topicfilter = topicmap.topicfilter(self.filtername)

            if not topic or topicfilter == self.filtername:

                return super(topicrepo, self).branchmap()

            return self.filtered(topicfilter).branchmap()

        def invalidatevolatilesets(self):

            # XXX we might be able to move this to something invalidated less often

            super(topicrepo, self).invalidatevolatilesets()

            self._topics = None

        def peer(self):

            peer = super(topicrepo, self).peer()

            if getattr(peer, '_repo', None) is not None: # localpeer

                class topicpeer(peer.__class__):

                    def branchmap(self):

                        usetopic = not self._repo.publishing()

                        return self._repo.branchmap(topic=usetopic)

                peer.__class__ = topicpeer

            return peer

    repo.__class__ = topicrepo

    repo._topics = None

    if util.safehasattr(repo, 'names'):

        repo.names.addnamespace(namespaces.namespace(

            'topics', 'topic', namemap=_namemap, nodemap=_nodemap,

            listnames=lambda repo: repo.topics))

@command('topics [TOPIC]', [

        ('', 'clear', False, 'clear active topic if any'),

        ('r', 'rev', '', 'revset of existing revisions', _('REV')),

        ('l', 'list', False, 'show the stack of changeset in the topic'),

        ('', 'age', False, 'show when you last touched the topics')

    ] + commands.formatteropts)

def topics(ui, repo, topic='', clear=False, rev=None, list=False, **opts):

    """View current topic, set current topic, change topic for a set of revisions, or see all topics.

    Clear topic on existing topiced revisions:

        `hg topic --rev <related revset> --clear`

    Change topic on some revisions:

        `hg topic <newtopicname> --rev <related revset>`

    Clear current topic:

        `hg topic --clear`

    Set current topic:

        `hg topic <topicname>`

    List of topics:

        `hg topics`

    List of topics with their last touched time sorted according to it:

        `hg topic --age`

    The active topic (if any) will be prepended with a "*".

    The --verbose version of this command display various information on the state of each topic."""

    if list:

        if clear or rev:

            raise error.Abort(_("cannot use --clear or --rev with --list"))

        if not topic:

            topic = repo.currenttopic

        if not topic:

            raise error.Abort(_('no active topic to list'))

        return stack.showstack(ui, repo, topic=topic, opts=opts)

    if rev:

        if not obsolete.isenabled(repo, obsolete.createmarkersopt):

            raise error.Abort(_('must have obsolete enabled to change topics'))

        if clear:

            topic = None

        elif not topic:

            raise error.Abort('changing topic requires a topic name or --clear')

        if any(not c.mutable() for c in repo.set('%r and public()', rev)):

            raise error.Abort("can't change topic of a public change")

        return _changetopics(ui, repo, rev, topic)

    if clear:

        return _changecurrenttopic(repo, None)

    if topic:

        return _changecurrenttopic(repo, topic)

    _listtopics(ui, repo, opts)

@command('stack [TOPIC]', [] + commands.formatteropts)

def cmdstack(ui, repo, topic='', **opts):

    """list all changesets in a topic and other information

    List the current topic by default."""

    if not topic:

        topic = None

    branch = None

    if topic is None and repo.currenttopic:

        topic = repo.currenttopic

    if topic is None:

        branch = repo[None].branch()

    return stack.showstack(ui, repo, branch=branch, topic=topic, opts=opts)

def _changecurrenttopic(repo, newtopic):

    """changes the current topic."""

    if newtopic:

        with repo.wlock():

            with repo.vfs.open('topic', 'w') as f:

                f.write(newtopic)

    else:

        if repo.vfs.exists('topic'):

            repo.vfs.unlink('topic')

def _changetopics(ui, repo, revset, newtopic):

    rewrote = 0

    wl = l = txn = None