# Patch transplanting extension for Mercurial

#

# Copyright 2006, 2007 Brendan Cully <brendan@kublai.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 transplant changesets from another branch

This extension allows you to transplant changes to another parent revision,

possibly in another repository. The transplant is done using 'diff' patches.

Transplanted patches are recorded in .hg/transplant/transplants, as a

map from a changeset hash to its hash in the source repository.

'''

from __future__ import absolute_import

import os

import tempfile

from mercurial.i18n import _

from mercurial import (

    bundlerepo,

    cmdutil,

    error,

    exchange,

    hg,

    match,

    merge,

    node as nodemod,

    patch,

    pycompat,

    registrar,

    revlog,

    revset,

    scmutil,

    smartset,

    util,

    vfs as vfsmod,

)

class TransplantError(error.Abort):

    pass

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'

configtable = {}

configitem = registrar.configitem(configtable)

configitem('transplant', 'filter',

    default=None,

)

configitem('transplant', 'log',

    default=None,

)

class transplantentry(object):

    def __init__(self, lnode, rnode):

        self.lnode = lnode

        self.rnode = rnode

class transplants(object):

    def __init__(self, path=None, transplantfile=None, opener=None):

        self.path = path

        self.transplantfile = transplantfile

        self.opener = opener

        if not opener:

            self.opener = vfsmod.vfs(self.path)

        self.transplants = {}

        self.dirty = False

        self.read()

    def read(self):

        abspath = os.path.join(self.path, self.transplantfile)

        if self.transplantfile and os.path.exists(abspath):

            for line in self.opener.read(self.transplantfile).splitlines():

                lnode, rnode = map(revlog.bin, line.split(':'))

                list = self.transplants.setdefault(rnode, [])

                list.append(transplantentry(lnode, rnode))

    def write(self):

        if self.dirty and self.transplantfile:

            if not os.path.isdir(self.path):

                os.mkdir(self.path)

            fp = self.opener(self.transplantfile, 'w')

            for list in self.transplants.itervalues():

                for t in list:

                    l, r = map(nodemod.hex, (t.lnode, t.rnode))

                    fp.write(l + ':' + r + '\n')

            fp.close()

        self.dirty = False

    def get(self, rnode):

        return self.transplants.get(rnode) or []

    def set(self, lnode, rnode):

        list = self.transplants.setdefault(rnode, [])

        list.append(transplantentry(lnode, rnode))

        self.dirty = True

    def remove(self, transplant):

        list = self.transplants.get(transplant.rnode)

        if list:

            del list[list.index(transplant)]

            self.dirty = True

class transplanter(object):

    def __init__(self, ui, repo, opts):

        self.ui = ui

        self.path = repo.vfs.join('transplant')

        self.opener = vfsmod.vfs(self.path)

        self.transplants = transplants(self.path, 'transplants',

                                       opener=self.opener)

        def getcommiteditor():

            editform = cmdutil.mergeeditform(repo[None], 'transplant')

            return cmdutil.getcommiteditor(editform=editform, **opts)

        self.getcommiteditor = getcommiteditor

    def applied(self, repo, node, parent):

        '''returns True if a node is already an ancestor of parent

        or is parent or has already been transplanted'''

        if hasnode(repo, parent):

            parentrev = repo.changelog.rev(parent)

        if hasnode(repo, node):

            rev = repo.changelog.rev(node)

            reachable = repo.changelog.ancestors([parentrev], rev,

                                                 inclusive=True)

            if rev in reachable:

                return True

        for t in self.transplants.get(node):

            # it might have been stripped

            if not hasnode(repo, t.lnode):

                self.transplants.remove(t)

                return False

            lnoderev = repo.changelog.rev(t.lnode)

            if lnoderev in repo.changelog.ancestors([parentrev], lnoderev,

                                                    inclusive=True):

                return True

        return False

    def apply(self, repo, source, revmap, merges, opts=None):

        '''apply the revisions in revmap one by one in revision order'''

        if opts is None:

            opts = {}

        revs = sorted(revmap)

        p1, p2 = repo.dirstate.parents()

        pulls = []

        diffopts = patch.difffeatureopts(self.ui, opts)

        diffopts.git = True

        lock = tr = None

        try:

            lock = repo.lock()

            tr = repo.transaction('transplant')

            for rev in revs:

                node = revmap[rev]

                revstr = '%s:%s' % (rev, nodemod.short(node))

                if self.applied(repo, node, p1):

                    self.ui.warn(_('skipping already applied revision %s\n') %

                                 revstr)

                    continue

                parents = source.changelog.parents(node)

                if not (opts.get('filter') or opts.get('log')):

                    # If the changeset parent is the same as the

                    # wdir's parent, just pull it.

                    if parents[0] == p1:

                        pulls.append(node)

                        p1 = node

                        continue

                    if pulls:

                        if source != repo:

                            exchange.pull(repo, source.peer(), heads=pulls)

                        merge.update(repo, pulls[-1], False, False)

                        p1, p2 = repo.dirstate.parents()

                        pulls = []

                domerge = False

                if node in merges:

                    # pulling all the merge revs at once would mean we

                    # couldn't transplant after the latest even if

                    # transplants before them fail.

                    domerge = True

                    if not hasnode(repo, node):

                        exchange.pull(repo, source.peer(), heads=[node])

                skipmerge = False

                if parents[1] != revlog.nullid:

                    if not opts.get('parent'):

                        self.ui.note(_('skipping merge changeset %s:%s\n')

                                     % (rev, nodemod.short(node)))

                        skipmerge = True

                    else:

                        parent = source.lookup(opts['parent'])

                        if parent not in parents:

                            raise error.Abort(_('%s is not a parent of %s') %

                                              (nodemod.short(parent),

                                               nodemod.short(node)))

                else:

                    parent = parents[0]

                if skipmerge:

                    patchfile = None

                else:

                    fd, patchfile = tempfile.mkstemp(prefix='hg-transplant-')

                    fp = os.fdopen(fd, pycompat.sysstr('w'))

                    gen = patch.diff(source, parent, node, opts=diffopts)

                    for chunk in gen:

                        fp.write(chunk)

                    fp.close()

                del revmap[rev]

                if patchfile or domerge:

                    try:

                        try:

                            n = self.applyone(repo, node,

                                              source.changelog.read(node),

                                              patchfile, merge=domerge,

                                              log=opts.get('log'),

                                              filter=opts.get('filter'))

                        except TransplantError:

                            # Do not rollback, it is up to the user to

                            # fix the merge or cancel everything

                            tr.close()

                            raise

                        if n and domerge:

                            self.ui.status(_('%s merged at %s\n') % (revstr,

                                      nodemod.short(n)))

                        elif n:

                            self.ui.status(_('%s transplanted to %s\n')

                                           % (nodemod.short(node),

                                              nodemod.short(n)))

                    finally:

                        if patchfile:

                            os.unlink(patchfile)

            tr.close()

            if pulls:

                exchange.pull(repo, source.peer(), heads=pulls)

                merge.update(repo, pulls[-1], False, False)

        finally:

            self.saveseries(revmap, merges)

            self.transplants.write()

            if tr:

                tr.release()

            if lock:

                lock.release()

    def filter(self, filter, node, changelog, patchfile):

        '''arbitrarily rewrite changeset before applying it'''

        self.ui.status(_('filtering %s\n') % patchfile)

        user, date, msg = (changelog[1], changelog[2], changelog[4])

        fd, headerfile = tempfile.mkstemp(prefix='hg-transplant-')

        fp = os.fdopen(fd, pycompat.sysstr('w'))

        fp.write("# HG changeset patch\n")

        fp.write("# User %s\n" % user)

        fp.write("# Date %d %d\n" % date)

        fp.write(msg + '\n')

        fp.close()

        try:

            self.ui.system('%s %s %s' % (filter, util.shellquote(headerfile),

                                         util.shellquote(patchfile)),

                           environ={'HGUSER': changelog[1],

                                    'HGREVISION': nodemod.hex(node),

                                    },

                           onerr=error.Abort, errprefix=_('filter failed'),

                           blockedtag='transplant_filter')

            user, date, msg = self.parselog(file(headerfile))[1:4]

        finally:

            os.unlink(headerfile)

        return (user, date, msg)

    def applyone(self, repo, node, cl, patchfile, merge=False, log=False,

                 filter=None):

        '''apply the patch in patchfile to the repository as a transplant'''

        (manifest, user, (time, timezone), files, message) = cl[:5]

        date = "%d %d" % (time, timezone)

        extra = {'transplant_source': node}

        if filter:

            (user, date, message) = self.filter(filter, node, cl, patchfile)

        if log:

            # we don't translate messages inserted into commits

            message += '\n(transplanted from %s)' % nodemod.hex(node)

        self.ui.status(_('applying %s\n') % nodemod.short(node))

        self.ui.note('%s %s\n%s\n' % (user, date, message))

        if not patchfile and not merge:

            raise error.Abort(_('can only omit patchfile if merging'))

        if patchfile:

            try:

                files = set()

                patch.patch(self.ui, repo, patchfile, files=files, eolmode=None)

                files = list(files)

            except Exception as inst:

                seriespath = os.path.join(self.path, 'series')

                if os.path.exists(seriespath):

                    os.unlink(seriespath)

                p1 = repo.dirstate.p1()

                p2 = node

                self.log(user, date, message, p1, p2, merge=merge)

                self.ui.write(str(inst) + '\n')

                raise TransplantError(_('fix up the working directory and run '

                                        'hg transplant --continue'))

        else:

            files = None

        if merge:

            p1, p2 = repo.dirstate.parents()

            repo.setparents(p1, node)

            m = match.always(repo.root, '')

        else:

            m = match.exact(repo.root, '', files)

        n = repo.commit(message, user, date, extra=extra, match=m,

                        editor=self.getcommiteditor())

        if not n:

            self.ui.warn(_('skipping emptied changeset %s\n') %

                           nodemod.short(node))

            return None

        if not merge:

            self.transplants.set(n, node)

        return n

    def canresume(self):

        return os.path.exists(os.path.join(self.path, 'journal'))

    def resume(self, repo, source, opts):

        '''recover last transaction and apply remaining changesets'''

        if os.path.exists(os.path.join(self.path, 'journal')):

            n, node = self.recover(repo, source, opts)

            if n:

                self.ui.status(_('%s transplanted as %s\n') %

                                 (nodemod.short(node),

                                  nodemod.short(n)))

            else:

                self.ui.status(_('%s skipped due to empty diff\n')

                               % (nodemod.short(node),))

        seriespath = os.path.join(self.path, 'series')

        if not os.path.exists(seriespath):

            self.transplants.write()

            return

        nodes, merges = self.readseries()

        revmap = {}

        for n in nodes:

            revmap[source.changelog.rev(n)] = n

        os.unlink(seriespath)