# rebase.py - rebasing feature for mercurial

#

# Copyright 2008 Stefano Tortarolo <stefano.tortarolo at gmail dot com>

#

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

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

'''command to move sets of revisions to a different ancestor

This extension lets you rebase changesets in an existing Mercurial

repository.

For more information:

https://mercurial-scm.org/wiki/RebaseExtension

'''

from __future__ import absolute_import

import errno

import os

from mercurial.i18n import _

from mercurial.node import (

    nullrev,

    short,

)

from mercurial.pycompat import open

from mercurial import (

    bookmarks,

    cmdutil,

    commands,

    copies,

    destutil,

    dirstateguard,

    error,

    extensions,

    merge as mergemod,

    mergestate as mergestatemod,

    mergeutil,

    node as nodemod,

    obsolete,

    obsutil,

    patch,

    phases,

    pycompat,

    registrar,

    repair,

    revset,

    revsetlang,

    rewriteutil,

    scmutil,

    smartset,

    state as statemod,

    util,

)

# The following constants are used throughout the rebase module. The ordering of

# their values must be maintained.

# Indicates that a revision needs to be rebased

revtodo = -1

revtodostr = b'-1'

# legacy revstates no longer needed in current code

# -2: nullmerge, -3: revignored, -4: revprecursor, -5: revpruned

legacystates = {b'-2', b'-3', b'-4', b'-5'}

cmdtable = {}

command = registrar.command(cmdtable)

# 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 = b'ships-with-hg-core'

def _nothingtorebase():

    return 1

def _savegraft(ctx, extra):

    s = ctx.extra().get(b'source', None)

    if s is not None:

        extra[b'source'] = s

    s = ctx.extra().get(b'intermediate-source', None)

    if s is not None:

        extra[b'intermediate-source'] = s

def _savebranch(ctx, extra):

    extra[b'branch'] = ctx.branch()

def _destrebase(repo, sourceset, destspace=None):

    """small wrapper around destmerge to pass the right extra args

    Please wrap destutil.destmerge instead."""

    return destutil.destmerge(

        repo,

        action=b'rebase',

        sourceset=sourceset,

        onheadcheck=False,

        destspace=destspace,

    )

revsetpredicate = registrar.revsetpredicate()

@revsetpredicate(b'_destrebase')

def _revsetdestrebase(repo, subset, x):

    # ``_rebasedefaultdest()``

    # default destination for rebase.

    # # XXX: Currently private because I expect the signature to change.

    # # XXX: - bailing out in case of ambiguity vs returning all data.

    # i18n: "_rebasedefaultdest" is a keyword

    sourceset = None

    if x is not None:

        sourceset = revset.getset(repo, smartset.fullreposet(repo), x)

    return subset & smartset.baseset([_destrebase(repo, sourceset)])

@revsetpredicate(b'_destautoorphanrebase')

def _revsetdestautoorphanrebase(repo, subset, x):

    # ``_destautoorphanrebase()``

    # automatic rebase destination for a single orphan revision.

    unfi = repo.unfiltered()

    obsoleted = unfi.revs(b'obsolete()')

    src = revset.getset(repo, subset, x).first()

    # Empty src or already obsoleted - Do not return a destination

    if not src or src in obsoleted:

        return smartset.baseset()

    dests = destutil.orphanpossibledestination(repo, src)

    if len(dests) > 1:

        raise error.Abort(

            _(b"ambiguous automatic rebase: %r could end up on any of %r")

            % (src, dests)

        )

    # We have zero or one destination, so we can just return here.

    return smartset.baseset(dests)

def _ctxdesc(ctx):

    """short description for a context"""

    )

class rebaseruntime(object):

    """This class is a container for rebase runtime state"""

    def __init__(self, repo, ui, inmemory=False, dryrun=False, opts=None):

        if opts is None:

            opts = {}

        # prepared: whether we have rebasestate prepared or not. Currently it

        # decides whether "self.repo" is unfiltered or not.

        # The rebasestate has explicit hash to hash instructions not depending

        # on visibility. If rebasestate exists (in-memory or on-disk), use

        # unfiltered repo to avoid visibility issues.

        # Before knowing rebasestate (i.e. when starting a new rebase (not

        # --continue or --abort)), the original repo should be used so

        # visibility-dependent revsets are correct.

        self.prepared = False

        self.resume = False

        self._repo = repo

        self.ui = ui

        self.opts = opts

        self.originalwd = None

        self.external = nullrev

        # Mapping between the old revision id and either what is the new rebased

        # revision or what needs to be done with the old revision. The state

        # dict will be what contains most of the rebase progress state.

        self.state = {}

        self.activebookmark = None

        self.destmap = {}

        self.skipped = set()

        self.collapsef = opts.get(b'collapse', False)

        self.collapsemsg = cmdutil.logmessage(ui, opts)

        self.date = opts.get(b'date', None)

        e = opts.get(b'extrafn')  # internal, used by e.g. hgsubversion

        self.extrafns = [_savegraft]

        if e:

            self.extrafns = [e]

        self.backupf = ui.configbool(b'rewrite', b'backup-bundle')

        self.keepf = opts.get(b'keep', False)

        self.keepbranchesf = opts.get(b'keepbranches', False)

        self.skipemptysuccessorf = rewriteutil.skip_empty_successor(

            repo.ui, b'rebase'

        )

        self.obsoletenotrebased = {}

        self.obsoletewithoutsuccessorindestination = set()

        self.inmemory = inmemory

        self.dryrun = dryrun

        self.stateobj = statemod.cmdstate(repo, b'rebasestate')

    @property

    def repo(self):

        if self.prepared:

            return self._repo.unfiltered()

        else:

            return self._repo

    def storestatus(self, tr=None):

        """Store the current status to allow recovery"""

        if tr:

            tr.addfilegenerator(

                b'rebasestate',

                (b'rebasestate',),

                self._writestatus,

                location=b'plain',

            )

        else:

            with self.repo.vfs(b"rebasestate", b"w") as f:

                self._writestatus(f)

    def _writestatus(self, f):

        repo = self.repo

        assert repo.filtername is None

        f.write(repo[self.originalwd].hex() + b'\n')

        # was "dest". we now write dest per src root below.

        f.write(b'\n')

        f.write(repo[self.external].hex() + b'\n')

        f.write(b'%d\n' % int(self.collapsef))

        f.write(b'%d\n' % int(self.keepf))

        f.write(b'%d\n' % int(self.keepbranchesf))

        f.write(b'%s\n' % (self.activebookmark or b''))

        destmap = self.destmap

        for d, v in pycompat.iteritems(self.state):

            oldrev = repo[d].hex()

            if v >= 0:

                newrev = repo[v].hex()

            else:

                newrev = b"%d" % v

            destnode = repo[destmap[d]].hex()

            f.write(b"%s:%s:%s\n" % (oldrev, newrev, destnode))

        repo.ui.debug(b'rebase status stored\n')

    def restorestatus(self):

        """Restore a previously stored status"""

        if not self.stateobj.exists():

            cmdutil.wrongtooltocontinue(self.repo, _(b'rebase'))

        data = self._read()

        self.repo.ui.debug(b'rebase status resumed\n')

        self.originalwd = data[b'originalwd']

        self.destmap = data[b'destmap']

        self.state = data[b'state']

        self.skipped = data[b'skipped']

        self.collapsef = data[b'collapse']

        self.keepf = data[b'keep']

        self.keepbranchesf = data[b'keepbranches']

        self.external = data[b'external']

        self.activebookmark = data[b'activebookmark']

    def _read(self):

        self.prepared = True

        repo = self.repo

        assert repo.filtername is None

        data = {

            b'keepbranches': None,

            b'collapse': None,

            b'activebookmark': None,

            b'external': nullrev,

            b'keep': None,

            b'originalwd': None,

        }

        legacydest = None

        state = {}

        destmap = {}

        if True:

            f = repo.vfs(b"rebasestate")

            for i, l in enumerate(f.read().splitlines()):

                if i == 0:

                    data[b'originalwd'] = repo[l].rev()

                elif i == 1:

                    # this line should be empty in newer version. but legacy

                    # clients may still use it

                    if l:

                        legacydest = repo[l].rev()

                elif i == 2:

                    data[b'external'] = repo[l].rev()

                elif i == 3:

                    data[b'collapse'] = bool(int(l))

                elif i == 4:

                    data[b'keep'] = bool(int(l))

                elif i == 5:

                    data[b'keepbranches'] = bool(int(l))

                elif i == 6 and not (len(l) == 81 and b':' in l):

                    # line 6 is a recent addition, so for backwards

                    # compatibility check that the line doesn't look like the

                    # oldrev:newrev lines

                    data[b'activebookmark'] = l

                else:

                    args = l.split(b':')

                    oldrev = repo[args[0]].rev()

                    newrev = args[1]

                    if newrev in legacystates:

                        continue

                    if len(args) > 2:

                        destrev = repo[args[2]].rev()

                    else:

                        destrev = legacydest

                    destmap[oldrev] = destrev

                    if newrev == revtodostr:

                        state[oldrev] = revtodo

                        # Legacy compat special case

                    else:

                        state[oldrev] = repo[newrev].rev()

        if data[b'keepbranches'] is None:

            raise error.Abort(_(b'.hg/rebasestate is incomplete'))

        data[b'destmap'] = destmap

        data[b'state'] = state

        skipped = set()

        # recompute the set of skipped revs

        if not data[b'collapse']:

            seen = set(destmap.values())

            for old, new in sorted(state.items()):

                if new != revtodo and new in seen:

                    skipped.add(old)

                seen.add(new)

        data[b'skipped'] = skipped

        repo.ui.debug(

            b'computed skipped revs: %s\n'

            % (b' '.join(b'%d' % r for r in sorted(skipped)) or b'')

        )

        return data

    def _handleskippingobsolete(self, obsoleterevs, destmap):

        """Compute structures necessary for skipping obsolete revisions

        obsoleterevs:   iterable of all obsolete revisions in rebaseset

        destmap:        {srcrev: destrev} destination revisions

        """

        self.obsoletenotrebased = {}

        if not self.ui.configbool(b'experimental', b'rebaseskipobsolete'):

            return

        obsoleteset = set(obsoleterevs)

        (

            self.obsoletenotrebased,

            self.obsoletewithoutsuccessorindestination,

            obsoleteextinctsuccessors,

        ) = _computeobsoletenotrebased(self.repo, obsoleteset, destmap)

        skippedset = set(self.obsoletenotrebased)

        skippedset.update(self.obsoletewithoutsuccessorindestination)

        skippedset.update(obsoleteextinctsuccessors)

        _checkobsrebase(self.repo, self.ui, obsoleteset, skippedset)

    def _prepareabortorcontinue(

        self, isabort, backup=True, suppwarns=False, dryrun=False, confirm=False

    ):

        self.resume = True

        try:

            self.restorestatus()