# hg.py - hg backend for convert extension

#

#  Copyright 2005-2009 Matt Mackall <mpm@selenic.com> and others

#

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

# GNU General Public License version 2, incorporated herein by reference.

# Notes for hg->hg conversion:

#

# * Old versions of Mercurial didn't trim the whitespace from the ends

#   of commit messages, but new versions do.  Changesets created by

#   those older versions, then converted, may thus have different

#   hashes for changesets that are otherwise identical.

#

# * Using "--config convert.hg.saverev=true" will make the source

#   identifier to be stored in the converted revision. This will cause

#   the converted revision to have a different identity than the

#   source.

import os, time, cStringIO

from mercurial.i18n import _

from mercurial.node import bin, hex, nullid

from mercurial import hg, util, context, error

from common import NoRepo, commit, converter_source, converter_sink

class mercurial_sink(converter_sink):

    def __init__(self, ui, path):

        converter_sink.__init__(self, ui, path)

        self.branchnames = ui.configbool('convert', 'hg.usebranchnames', True)

        self.clonebranches = ui.configbool('convert', 'hg.clonebranches', False)

        self.tagsbranch = ui.config('convert', 'hg.tagsbranch', 'default')

        self.lastbranch = None

        if os.path.isdir(path) and len(os.listdir(path)) > 0:

            try:

                self.repo = hg.repository(self.ui, path)

                if not self.repo.local():

                    raise NoRepo(_('%s is not a local Mercurial repo') % path)

            except error.RepoError, err:

                ui.traceback()

                raise NoRepo(err.args[0])

        else:

            try:

                ui.status(_('initializing destination %s repository\n') % path)

                self.repo = hg.repository(self.ui, path, create=True)

                if not self.repo.local():

                    raise NoRepo(_('%s is not a local Mercurial repo') % path)

                self.created.append(path)

            except error.RepoError:

                ui.traceback()

                raise NoRepo("could not create hg repo %s as sink" % path)

        self.lock = None

        self.wlock = None

        self.filemapmode = False

    def before(self):

        self.ui.debug(_('run hg sink pre-conversion action\n'))

        self.wlock = self.repo.wlock()

        self.lock = self.repo.lock()

    def after(self):

        self.ui.debug(_('run hg sink post-conversion action\n'))

        self.lock.release()

        self.wlock.release()

    def revmapfile(self):

        return os.path.join(self.path, ".hg", "shamap")

    def authorfile(self):

        return os.path.join(self.path, ".hg", "authormap")

    def getheads(self):

        h = self.repo.changelog.heads()

        return [ hex(x) for x in h ]

    def setbranch(self, branch, pbranches):

        if not self.clonebranches:

            return

        setbranch = (branch != self.lastbranch)

        self.lastbranch = branch

        if not branch:

            branch = 'default'

        pbranches = [(b[0], b[1] and b[1] or 'default') for b in pbranches]

        pbranch = pbranches and pbranches[0][1] or 'default'

        branchpath = os.path.join(self.path, branch)

        if setbranch:

            self.after()

            try:

                self.repo = hg.repository(self.ui, branchpath)

            except:

                self.repo = hg.repository(self.ui, branchpath, create=True)

            self.before()

        # pbranches may bring revisions from other branches (merge parents)

        # Make sure we have them, or pull them.

        missings = {}

        for b in pbranches:

            try:

                self.repo.lookup(b[0])

            except:

                missings.setdefault(b[1], []).append(b[0])

        if missings:

            self.after()

            for pbranch, heads in missings.iteritems():

                pbranchpath = os.path.join(self.path, pbranch)

                prepo = hg.repository(self.ui, pbranchpath)

                self.ui.note(_('pulling from %s into %s\n') % (pbranch, branch))

                self.repo.pull(prepo, [prepo.lookup(h) for h in heads])

            self.before()

    def _rewritetags(self, source, revmap, data):

        fp = cStringIO.StringIO()

        for line in data.splitlines():

            s = line.split(' ', 1)

            if len(s) != 2:

                continue

            revid = revmap.get(source.lookuprev(s[0]))

            if not revid:

                continue

            fp.write('%s %s\n' % (revid, s[1]))

        return fp.getvalue()

    def putcommit(self, files, copies, parents, commit, source, revmap):

        files = dict(files)

        def getfilectx(repo, memctx, f):

            v = files[f]

            data = source.getfile(f, v)

            e = source.getmode(f, v)

            if f == '.hgtags':

                data = self._rewritetags(source, revmap, data)

            return context.memfilectx(f, data, 'l' in e, 'x' in e, copies.get(f))

        pl = []

        for p in parents:

            if p not in pl:

                pl.append(p)

        parents = pl

        nparents = len(parents)

        if self.filemapmode and nparents == 1:

            m1node = self.repo.changelog.read(bin(parents[0]))[0]

            parent = parents[0]

        if len(parents) < 2: parents.append(nullid)

        if len(parents) < 2: parents.append(nullid)

        p2 = parents.pop(0)

        text = commit.desc

        extra = commit.extra.copy()

        if self.branchnames and commit.branch:

            extra['branch'] = commit.branch

        if commit.rev:

            extra['convert_revision'] = commit.rev

        while parents:

            p1 = p2

            p2 = parents.pop(0)

            ctx = context.memctx(self.repo, (p1, p2), text, files.keys(), getfilectx,

                                 commit.author, commit.date, extra)

            self.repo.commitctx(ctx)

            text = "(octopus merge fixup)\n"

            p2 = hex(self.repo.changelog.tip())

        if self.filemapmode and nparents == 1:

            man = self.repo.manifest

            mnode = self.repo.changelog.read(bin(p2))[0]

            if not man.cmp(m1node, man.revision(mnode)):

                self.ui.status(_("filtering out empty revision\n"))

                self.repo.rollback()

                return parent

        return p2

    def puttags(self, tags):

        try:

            parentctx = self.repo[self.tagsbranch]

            tagparent = parentctx.node()

        except error.RepoError:

            parentctx = None

            tagparent = nullid

        try:

            oldlines = sorted(parentctx['.hgtags'].data().splitlines(1))

        except:

            oldlines = []

        newlines = sorted([("%s %s\n" % (tags[tag], tag)) for tag in tags])

        if newlines == oldlines:

            return None

        data = "".join(newlines)

        def getfilectx(repo, memctx, f):

            return context.memfilectx(f, data, False, False, None)

        self.ui.status(_("updating tags\n"))

        date = "%s 0" % int(time.mktime(time.gmtime()))

        extra = {'branch': self.tagsbranch}

        ctx = context.memctx(self.repo, (tagparent, None), "update tags",

                             [".hgtags"], getfilectx, "convert-repo", date,

                             extra)

        self.repo.commitctx(ctx)

        return hex(self.repo.changelog.tip())

    def setfilemapmode(self, active):

        self.filemapmode = active

class mercurial_source(converter_source):

    def __init__(self, ui, path, rev=None):

        converter_source.__init__(self, ui, path, rev)

        self.ignoreerrors = ui.configbool('convert', 'hg.ignoreerrors', False)

        self.ignored = set()

        self.saverev = ui.configbool('convert', 'hg.saverev', False)

        try:

            self.repo = hg.repository(self.ui, path)

            # try to provoke an exception if this isn't really a hg

            # repo, but some other bogus compatible-looking url

            if not self.repo.local():

                raise error.RepoError()

        except error.RepoError:

            ui.traceback()

            raise NoRepo("%s is not a local Mercurial repo" % path)

        self.lastrev = None

        self.lastctx = None

        self._changescache = None

        self.convertfp = None

        # Restrict converted revisions to startrev descendants

        startnode = ui.config('convert', 'hg.startrev')

        if startnode is not None:

            try:

                startnode = self.repo.lookup(startnode)

            except error.RepoError:

                raise util.Abort(_('%s is not a valid start revision')

                                 % startnode)

            startrev = self.repo.changelog.rev(startnode)

            children = {startnode: 1}

            for rev in self.repo.changelog.descendants(startrev):

                children[self.repo.changelog.node(rev)] = 1

            self.keep = children.__contains__

        else:

            self.keep = util.always

    def changectx(self, rev):

        if self.lastrev != rev:

            self.lastctx = self.repo[rev]

            self.lastrev = rev

        return self.lastctx

    def parents(self, ctx):

        return [p.node() for p in ctx.parents()

                if p and self.keep(p.node())]

    def getheads(self):

        if self.rev:

            heads = [self.repo[self.rev].node()]

        else:

            heads = self.repo.heads()

        return [hex(h) for h in heads if self.keep(h)]

    def getfile(self, name, rev):

        try:

            return self.changectx(rev)[name].data()

        except error.LookupError, err:

            raise IOError(err)

    def getmode(self, name, rev):

        return self.changectx(rev).manifest().flags(name)

    def getchanges(self, rev):

        ctx = self.changectx(rev)

        parents = self.parents(ctx)

        if not parents:

            files = sorted(ctx.manifest())

            if self.ignoreerrors:

                # calling getcopies() is a simple way to detect missing

                # revlogs and populate self.ignored

                self.getcopies(ctx, files)

            return [(f, rev) for f in files if f not in self.ignored], {}

        if self._changescache and self._changescache[0] == rev:

            m, a, r = self._changescache[1]

        else:

            m, a, r = self.repo.status(parents[0], ctx.node())[:3]

        # getcopies() detects missing revlogs early, run it before

        # filtering the changes.

        copies = self.getcopies(ctx, m + a)

        changes = [(name, rev) for name in m + a + r

                   if name not in self.ignored]

        return sorted(changes), copies

    def getcopies(self, ctx, files):

        copies = {}

        for name in files:

            if name in self.ignored:

                continue

            try:

                copysource, copynode = ctx.filectx(name).renamed()

                if copysource in self.ignored or not self.keep(copynode):

                    continue

                copies[name] = copysource

            except TypeError:

                pass

            except error.LookupError, e:

                if not self.ignoreerrors:

                    raise

                self.ignored.add(name)

                self.ui.warn(_('ignoring: %s\n') % e)

        return copies

    def getcommit(self, rev):

        ctx = self.changectx(rev)

        parents = [hex(p) for p in self.parents(ctx)]

        if self.saverev:

            crev = rev

        else:

            crev = None

        return commit(author=ctx.user(), date=util.datestr(ctx.date()),

                      desc=ctx.description(), rev=crev, parents=parents,

                      branch=ctx.branch(), extra=ctx.extra(),

                      sortkey=ctx.rev())

    def gettags(self):

        tags = [t for t in self.repo.tagslist() if t[0] != 'tip']

        return dict([(name, hex(node)) for name, node in tags

                     if self.keep(node)])

    def getchangedfiles(self, rev, i):

        ctx = self.changectx(rev)

        parents = self.parents(ctx)

        if not parents and i is None:

            i = 0

            changes = [], ctx.manifest().keys(), []

        else:

            i = i or 0

            changes = self.repo.status(parents[i], ctx.node())[:3]

        changes = [[f for f in l if f not in self.ignored] for l in changes]

        if i == 0:

            self._changescache = (rev, changes)

        return changes[0] + changes[1] + changes[2]