# 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 (

    nullid,

    nullrev,

    short,

)

from mercurial import (

    bookmarks,

    cmdutil,

    commands,

    copies,

    destutil,

    dirstateguard,

    error,

    extensions,

    hg,

    lock,

    merge as mergemod,

    mergeutil,

    obsolete,

    obsutil,

    patch,

    phases,

    pycompat,

    registrar,

    repair,

    revset,

    revsetlang,

    scmutil,

    smartset,

    util,

)

release = lock.release

# 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 = '-1'

# legacy revstates no longer needed in current code

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

legacystates = {'-2', '-3', '-4', '-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 = 'ships-with-hg-core'

def _nothingtorebase():

    return 1

def _savegraft(ctx, extra):

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

    if s is not None:

        extra['source'] = s

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

    if s is not None:

        extra['intermediate-source'] = s

def _savebranch(ctx, extra):

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

def _makeextrafn(copiers):

    """make an extrafn out of the given copy-functions.

    A copy function takes a context and an extra dict, and mutates the

    extra dict as needed based on the given context.

    """

    def extrafn(ctx, extra):

        for c in copiers:

            c(ctx, extra)

    return extrafn

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='rebase', sourceset=sourceset,

                              onheadcheck=False, destspace=destspace)

revsetpredicate = registrar.revsetpredicate()

@revsetpredicate('_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)])

def _ctxdesc(ctx):

    """short description for a context"""

    desc = '%d:%s "%s"' % (ctx.rev(), ctx,

                           ctx.description().split('\n', 1)[0])

    repo = ctx.repo()

    names = []

    for nsname, ns in repo.names.iteritems():

        if nsname == 'branches':

            continue

        names.extend(ns.names(repo, ctx.node()))

    if names:

        desc += ' (%s)' % ' '.join(names)

    return desc

class rebaseruntime(object):

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

    def __init__(self, repo, ui, inmemory=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._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('collapse', False)

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

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

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

        self.extrafns = [_savegraft]

        if e:

            self.extrafns = [e]

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

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

        self.obsoletenotrebased = {}

        self.obsoletewithoutsuccessorindestination = set()

        self.inmemory = inmemory

    @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('rebasestate', ('rebasestate',),

                                self._writestatus, location='plain')

        else:

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

                self._writestatus(f)

    def _writestatus(self, f):

        repo = self.repo

        assert repo.filtername is None

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

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

        f.write('\n')

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

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

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

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

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

        destmap = self.destmap

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

            oldrev = repo[d].hex()

            if v >= 0:

                newrev = repo[v].hex()

            else:

                newrev = "%d" % v

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

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

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

    def restorestatus(self):

        """Restore a previously stored status"""

        self.prepared = True

        repo = self.repo

        assert repo.filtername is None

        keepbranches = None

        legacydest = None

        collapse = False

        external = nullrev

        activebookmark = None

        state = {}

        destmap = {}

        try:

            f = repo.vfs("rebasestate")

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

                if i == 0:

                    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:

                    external = repo[l].rev()

                elif i == 3:

                    collapse = bool(int(l))

                elif i == 4:

                    keep = bool(int(l))

                elif i == 5:

                    keepbranches = bool(int(l))

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

                    # line 6 is a recent addition, so for backwards

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

                    # oldrev:newrev lines

                    activebookmark = l

                else:

                    args = l.split(':')

                    oldrev = args[0]

                    newrev = args[1]

                    if newrev in legacystates:

                        continue

                    if len(args) > 2:

                        destnode = args[2]

                    else:

                        destnode = legacydest

                    destmap[repo[oldrev].rev()] = repo[destnode].rev()

                    if newrev in (nullid, revtodostr):

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

                        # Legacy compat special case

                    else:

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

        except IOError as err:

            if err.errno != errno.ENOENT:

                raise

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

        if keepbranches is None:

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

        skipped = set()

        # recompute the set of skipped revs

        if not 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)

        repo.ui.debug('computed skipped revs: %s\n' %

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

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

        self.originalwd = originalwd

        self.destmap = destmap

        self.state = state

        self.skipped = skipped

        self.collapsef = collapse

        self.keepf = keep

        self.keepbranchesf = keepbranches

        self.external = external

        self.activebookmark = activebookmark

    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('experimental', '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):

        try:

            self.restorestatus()

            self.collapsemsg = restorecollapsemsg(self.repo, isabort)

        except error.RepoLookupError:

            if isabort:

                clearstatus(self.repo)

                clearcollapsemsg(self.repo)

                self.repo.ui.warn(_('rebase aborted (no revision is removed,'

                                    ' only broken state is cleared)\n'))

                return 0

            else:

                msg = _('cannot continue inconsistent rebase')

                hint = _('use "hg rebase --abort" to clear broken state')

                raise error.Abort(msg, hint=hint)

        if isabort:

            return abort(self.repo, self.originalwd, self.destmap,

                         self.state, activebookmark=self.activebookmark)

    def _preparenewrebase(self, destmap):

        if not destmap:

            return _nothingtorebase()

        rebaseset = destmap.keys()

        allowunstable = obsolete.isenabled(self.repo, obsolete.allowunstableopt)

        if (not (self.keepf or allowunstable)

              and self.repo.revs('first(children(%ld) - %ld)',

                                 rebaseset, rebaseset)):

            raise error.Abort(

                _("can't remove original changesets with"

                  " unrebased descendants"),

                hint=_('use --keep to keep original changesets'))

        result = buildstate(self.repo, destmap, self.collapsef)

        if not result:

            # Empty state built, nothing to rebase

            self.ui.status(_('nothing to rebase\n'))

            return _nothingtorebase()

        for root in self.repo.set('roots(%ld)', rebaseset):

            if not self.keepf and not root.mutable():

                raise error.Abort(_("can't rebase public changeset %s")

                                  % root,

                                  hint=_("see 'hg help phases' for details"))

        (self.originalwd, self.destmap, self.state) = result

        if self.collapsef:

            dests = set(self.destmap.values())

            if len(dests) != 1:

                raise error.Abort(

                    _('--collapse does not work with multiple destinations'))

            destrev = next(iter(dests))

            destancestors = self.repo.changelog.ancestors([destrev],

                                                          inclusive=True)

            self.external = externalparent(self.repo, self.state, destancestors)

        for destrev in sorted(set(destmap.values())):

            dest = self.repo[destrev]

            if dest.closesbranch() and not self.keepbranchesf:

                self.ui.status(_('reopening closed branch head %s\n') % dest)

        self.prepared = True

    def _assignworkingcopy(self):

        if self.inmemory:

            from mercurial.context import overlayworkingctx

            self.wctx = overlayworkingctx(self.repo)

            self.repo.ui.debug("rebasing in-memory\n")

        else:

            self.wctx = self.repo[None]

            self.repo.ui.debug("rebasing on disk\n")

        self.repo.ui.log("rebase", "", rebase_imm_used=self.inmemory)

    def _performrebase(self, tr):

        self._assignworkingcopy()

        repo, ui = self.repo, self.ui

        if self.keepbranchesf:

            # insert _savebranch at the start of extrafns so if

            # there's a user-provided extrafn it can clobber branch if

            # desired

            self.extrafns.insert(0, _savebranch)

            if self.collapsef:

                branches = set()

                for rev in self.state:

                    branches.add(repo[rev].branch())

                    if len(branches) > 1:

                        raise error.Abort(_('cannot collapse multiple named '

                            'branches'))

        # Calculate self.obsoletenotrebased

        obsrevs = _filterobsoleterevs(self.repo, self.state)

        self._handleskippingobsolete(obsrevs, self.destmap)

        # Keep track of the active bookmarks in order to reset them later

        self.activebookmark = self.activebookmark or repo._activebookmark

        if self.activebookmark:

            bookmarks.deactivate(repo)

        # Store the state before we begin so users can run 'hg rebase --abort'

        # if we fail before the transaction closes.

        self.storestatus()

        if tr:

            # When using single transaction, store state when transaction

            # commits.

            self.storestatus(tr)

        cands = [k for k, v in self.state.iteritems() if v == revtodo]

        total = len(cands)

        posholder = [0]

        def progress(ctx):

            posholder[0] += 1

            self.repo.ui.progress(_("rebasing"), posholder[0],

                                  ("%d:%s" % (ctx.rev(), ctx)),

                                  _('changesets'), total)

        allowdivergence = self.ui.configbool(

            'experimental', 'evolution.allowdivergence')

        for subset in sortsource(self.destmap):

            sortedrevs = self.repo.revs('sort(%ld, -topo)', subset)

            if not allowdivergence:

                sortedrevs -= self.repo.revs(

                    'descendants(%ld) and not %ld',

                    self.obsoletewithoutsuccessorindestination,

                    self.obsoletewithoutsuccessorindestination,

                )

            for rev in sortedrevs:

                self._rebasenode(tr, rev, allowdivergence, progress)

        ui.progress(_('rebasing'), None)

        ui.note(_('rebase merging completed\n'))

    def _rebasenode(self, tr, rev, allowdivergence, progressfn):

        repo, ui, opts = self.repo, self.ui, self.opts

        dest = self.destmap[rev]

        ctx = repo[rev]

        desc = _ctxdesc(ctx)

        if self.state[rev] == rev:

            ui.status(_('already rebased %s\n') % desc)

        elif (not allowdivergence

              and rev in self.obsoletewithoutsuccessorindestination):

            msg = _('note: not rebasing %s and its descendants as '

                    'this would cause divergence\n') % desc

            repo.ui.status(msg)

            self.skipped.add(rev)

        elif rev in self.obsoletenotrebased:

            succ = self.obsoletenotrebased[rev]

            if succ is None:

                msg = _('note: not rebasing %s, it has no '

                        'successor\n') % desc

            else:

                succdesc = _ctxdesc(repo[succ])

                msg = (_('note: not rebasing %s, already in '

                         'destination as %s\n') % (desc, succdesc))

            repo.ui.status(msg)

            # Make clearrebased aware state[rev] is not a true successor

            self.skipped.add(rev)

            # Record rev as moved to its desired destination in self.state.

            # This helps bookmark and working parent movement.

            dest = max(adjustdest(repo, rev, self.destmap, self.state,

                                  self.skipped))

            self.state[rev] = dest

        elif self.state[rev] == revtodo:

            ui.status(_('rebasing %s\n') % desc)

            progressfn(ctx)

            p1, p2, base = defineparents(repo, rev, self.destmap,

                                         self.state, self.skipped,

                                         self.obsoletenotrebased)