# 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 or any later version.

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

from __future__ import absolute_import

import os

import re

import time

from mercurial.i18n import _

from mercurial.pycompat import open

from mercurial import (

    bookmarks,

    context,

    error,

    exchange,

    hg,

    lock as lockmod,

    merge as mergemod,

    node as nodemod,

    phases,

    scmutil,

    util,

)

from mercurial.utils import dateutil

stringio = util.stringio

from . import common

mapfile = common.mapfile

NoRepo = common.NoRepo

sha1re = re.compile(br'\b[0-9a-f]{12,40}\b')

class mercurial_sink(common.converter_sink):

    def __init__(self, ui, repotype, path):

        common.converter_sink.__init__(self, ui, repotype, path)

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

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

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

        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(

                        _(b'%s is not a local Mercurial repository') % path

                    )

            except error.RepoError as err:

                ui.traceback()

                raise NoRepo(err.args[0])

        else:

            try:

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

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

                if not self.repo.local():

                    raise NoRepo(

                        _(b'%s is not a local Mercurial repository') % path

                    )

                self.created.append(path)

            except error.RepoError:

                ui.traceback()

                raise NoRepo(

                    _(b"could not create hg repository %s as sink") % path

                )

        self.lock = None

        self.wlock = None

        self.filemapmode = False

        self.subrevmaps = {}

    def before(self):

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

        self.wlock = self.repo.wlock()

        self.lock = self.repo.lock()

    def after(self):

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

        if self.lock:

            self.lock.release()

        if self.wlock:

            self.wlock.release()

    def revmapfile(self):

        return self.repo.vfs.join(b"shamap")

    def authorfile(self):

        return self.repo.vfs.join(b"authormap")

    def setbranch(self, branch, pbranches):

        if not self.clonebranches:

            return

        setbranch = branch != self.lastbranch

        self.lastbranch = branch

        if not branch:

            branch = b'default'

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

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

        if setbranch:

            self.after()

            try:

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

            except Exception:

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

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

        if missings:

            self.after()

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

                prepo = hg.peer(self.ui, {}, pbranchpath)

                self.ui.note(

                    _(b'pulling from %s into %s\n') % (pbranch, branch)

                )

                exchange.pull(

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

                )

            self.before()

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

        fp = stringio()

        for line in data.splitlines():

            s = line.split(b' ', 1)

            if len(s) != 2:

                self.ui.warn(_(b'invalid tag entry: "%s"\n') % line)

                fp.write(b'%s\n' % line)  # Bogus, but keep for hash stability

                continue

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

            if not revid:

                if s[0] == nodemod.nullhex:

                    revid = s[0]

                else:

                    # missing, but keep for hash stability

                    self.ui.warn(_(b'missing tag entry: "%s"\n') % line)

                    fp.write(b'%s\n' % line)

                    continue

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

        return fp.getvalue()

    def _rewritesubstate(self, source, data):

        fp = stringio()

        for line in data.splitlines():

            s = line.split(b' ', 1)

            if len(s) != 2:

                continue

            revid = s[0]

            subpath = s[1]

            if revid != nodemod.nullhex:

                revmap = self.subrevmaps.get(subpath)

                if revmap is None:

                    revmap = mapfile(

                        self.ui, self.repo.wjoin(subpath, b'.hg/shamap')

                    )

                    self.subrevmaps[subpath] = revmap

                    # It is reasonable that one or more of the subrepos don't

                    # need to be converted, in which case they can be cloned

                    # into place instead of converted.  Therefore, only warn

                    # once.

                    msg = _(b'no ".hgsubstate" updates will be made for "%s"\n')

                    if len(revmap) == 0:

                        sub = self.repo.wvfs.reljoin(subpath, b'.hg')

                        if self.repo.wvfs.exists(sub):

                            self.ui.warn(msg % subpath)

                newid = revmap.get(revid)

                if not newid:

                    if len(revmap) > 0:

                        self.ui.warn(

                            _(b"%s is missing from %s/.hg/shamap\n")

                            % (revid, subpath)

                        )

                else:

                    revid = newid

            fp.write(b'%s %s\n' % (revid, subpath))

        return fp.getvalue()

    def _calculatemergedfiles(self, source, p1ctx, p2ctx):

        """Calculates the files from p2 that we need to pull in when merging p1

        and p2, given that the merge is coming from the given source.

        This prevents us from losing files that only exist in the target p2 and

        that don't come from the source repo (like if you're merging multiple

        repositories together).

        """

        anc = [p1ctx.ancestor(p2ctx)]

        # Calculate what files are coming from p2

        actions, diverge, rename = mergemod.calculateupdates(

            self.repo,

            p1ctx,

            p2ctx,

            anc,

            branchmerge=True,

            force=True,

            acceptremote=False,

            followcopies=False,

        )

            if source.targetfilebelongstosource(file):

                # If the file belongs to the source repo, ignore the p2

                # since it will be covered by the existing fileset.

                continue

            # If the file requires actual merging, abort. We don't have enough

            # context to resolve merges correctly.

            if action in [b'm', b'dm', b'cd', b'dc']:

                raise error.Abort(

                    _(

                        b"unable to convert merge commit "

                        b"since target parents do not merge cleanly (file "

                        b"%s, parents %s and %s)"

                    )

                    % (file, p1ctx, p2ctx)

                )

            elif action == b'k':

                # 'keep' means nothing changed from p1

                continue

            else:

                # Any other change means we want to take the p2 version

                yield file

    def putcommit(

        self, files, copies, parents, commit, source, revmap, full, cleanp2

    ):

        files = dict(files)

        def getfilectx(repo, memctx, f):

            if p2ctx and f in p2files and f not in copies:

                self.ui.debug(b'reusing %s from p2\n' % f)

                try:

                    return p2ctx[f]

                except error.ManifestLookupError:

                    # If the file doesn't exist in p2, then we're syncing a

                    # delete, so just return None.

                    return None

            try:

                v = files[f]

            except KeyError:

                return None

            data, mode = source.getfile(f, v)

            if data is None:

                return None

            if f == b'.hgtags':

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

            if f == b'.hgsubstate':

                data = self._rewritesubstate(source, data)

            return context.memfilectx(

                self.repo,

                memctx,

                f,

                data,

                b'l' in mode,

                b'x' in mode,

                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(nodemod.bin(parents[0]))[0]

            parent = parents[0]

        if len(parents) < 2:

            parents.append(nodemod.nullid)

        if len(parents) < 2:

            parents.append(nodemod.nullid)

        p2 = parents.pop(0)

        text = commit.desc

        sha1s = re.findall(sha1re, text)

        for sha1 in sha1s:

            oldrev = source.lookuprev(sha1)

            newrev = revmap.get(oldrev)

            if newrev is not None:

                text = text.replace(sha1, newrev[: len(sha1)])

        extra = commit.extra.copy()

        sourcename = self.repo.ui.config(b'convert', b'hg.sourcename')

        if sourcename:

            extra[b'convert_source'] = sourcename

        for label in (

            b'source',

            b'transplant_source',

            b'rebase_source',

            b'intermediate-source',

        ):

            node = extra.get(label)

            if node is None:

                continue

            # Only transplant stores its reference in binary

            if label == b'transplant_source':

                node = nodemod.hex(node)

            newrev = revmap.get(node)

            if newrev is not None:

                if label == b'transplant_source':

                    newrev = nodemod.bin(newrev)

                extra[label] = newrev

        if self.branchnames and commit.branch:

            extra[b'branch'] = commit.branch

        if commit.rev and commit.saverev:

            extra[b'convert_revision'] = commit.rev

        while parents:

            p1 = p2

            p2 = parents.pop(0)

            p1ctx = self.repo[p1]

            p2ctx = None

            if p2 != nodemod.nullid:

                p2ctx = self.repo[p2]

            fileset = set(files)

            if full:

                fileset.update(self.repo[p1])

                fileset.update(self.repo[p2])

            if p2ctx:

                p2files = set(cleanp2)

                for file in self._calculatemergedfiles(source, p1ctx, p2ctx):

                    p2files.add(file)

                    fileset.add(file)

            ctx = context.memctx(