# 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

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

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

'''

from mercurial.i18n import _

import os, tempfile

from mercurial.node import short

from mercurial import bundlerepo, hg, merge, match

from mercurial import patch, revlog, scmutil, util, error, cmdutil

from mercurial import revset, templatekw

class TransplantError(error.Abort):

    pass

cmdtable = {}

command = cmdutil.command(cmdtable)

testedwith = 'internal'

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 = scmutil.opener(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(revlog.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):

        self.ui = ui

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

        self.opener = scmutil.opener(self.path)

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

                                       opener=self.opener)

        self.editor = None

    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={}):

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

        revs = sorted(revmap)

        p1, p2 = repo.dirstate.parents()

        pulls = []

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

        diffopts.git = True

        lock = wlock = tr = None

        try:

            wlock = repo.wlock()

            lock = repo.lock()

            tr = repo.transaction('transplant')

            for rev in revs:

                node = revmap[rev]

                revstr = '%s:%s' % (rev, 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:

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

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

                        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):

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

                skipmerge = False

                if parents[1] != revlog.nullid:

                    if not opts.get('parent'):

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

                                     % (rev, short(node)))

                        skipmerge = True

                    else:

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

                        if parent not in parents:

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

                                             (short(parent), short(node)))

                else:

                    parent = parents[0]

                if skipmerge:

                    patchfile = None

                else:

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

                    fp = os.fdopen(fd, '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,

                                      short(n)))

                        elif n:

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

                                           % (short(node),

                                              short(n)))

                    finally:

                        if patchfile:

                            os.unlink(patchfile)

            tr.close()

            if pulls:

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

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

        finally:

            self.saveseries(revmap, merges)

            self.transplants.write()

            if tr:

                tr.release()

            lock.release()

            wlock.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, '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:

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

                                   util.shellquote(patchfile)),

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

                                 'HGREVISION': revlog.hex(node),

                                 },

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

                        out=self.ui.fout)

            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)' % revlog.hex(node)

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

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

        if not patchfile and not merge:

            raise util.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, 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 merge 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.editor)

        if not n:

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

            return None

        if not merge:

            self.transplants.set(n, node)

        return n

    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)

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

                                                           short(n)))

        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)

        self.apply(repo, source, revmap, merges, opts)

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

        '''commit working directory using journal metadata'''

        node, user, date, message, parents = self.readlog()

        merge = False

        if not user or not date or not message or not parents[0]:

            raise util.Abort(_('transplant log file is corrupt'))

        parent = parents[0]

        if len(parents) > 1:

            if opts.get('parent'):

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

                if parent not in parents:

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

                                     (short(parent), short(node)))

            else:

                merge = True

        extra = {'transplant_source': node}

        wlock = repo.wlock()

        try:

            p1, p2 = repo.dirstate.parents()

            if p1 != parent:

                raise util.Abort(

                    _('working dir not at transplant parent %s') %

                                 revlog.hex(parent))

            if merge:

                repo.setparents(p1, parents[1])

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

                            editor=self.editor)

            if not n:

                raise util.Abort(_('commit failed'))

            if not merge:

                self.transplants.set(n, node)

            self.unlog()

            return n, node

        finally: