# convcmd - convert extension commands definition

#

# Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>

#

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

# GNU General Public License version 2 or any later version.

import collections

import heapq

import os

import shutil

from mercurial.i18n import _

from mercurial.pycompat import open

from mercurial import (

    encoding,

    error,

    hg,

    pycompat,

    scmutil,

    util,

)

from mercurial.utils import dateutil

from . import (

    bzr,

    common,

    cvs,

    darcs,

    filemap,

    git,

    gnuarch,

    hg as hgconvert,

    monotone,

    p4,

    subversion,

)

mapfile = common.mapfile

MissingTool = common.MissingTool

NoRepo = common.NoRepo

SKIPREV = common.SKIPREV

bzr_source = bzr.bzr_source

convert_cvs = cvs.convert_cvs

convert_git = git.convert_git

darcs_source = darcs.darcs_source

gnuarch_source = gnuarch.gnuarch_source

mercurial_sink = hgconvert.mercurial_sink

mercurial_source = hgconvert.mercurial_source

monotone_source = monotone.monotone_source

p4_source = p4.p4_source

svn_sink = subversion.svn_sink

svn_source = subversion.svn_source

orig_encoding = b'ascii'

def readauthormap(ui, authorfile, authors=None):

    if authors is None:

        authors = {}

    with open(authorfile, b'rb') as afile:

        for line in afile:

            line = line.strip()

            if not line or line.startswith(b'#'):

                continue

            try:

                srcauthor, dstauthor = line.split(b'=', 1)

            except ValueError:

                msg = _(b'ignoring bad line in author map file %s: %s\n')

                ui.warn(msg % (authorfile, line.rstrip()))

                continue

            srcauthor = srcauthor.strip()

            dstauthor = dstauthor.strip()

            if authors.get(srcauthor) in (None, dstauthor):

                msg = _(b'mapping author %s to %s\n')

                ui.debug(msg % (srcauthor, dstauthor))

                authors[srcauthor] = dstauthor

                continue

            m = _(b'overriding mapping for author %s, was %s, will be %s\n')

            ui.status(m % (srcauthor, authors[srcauthor], dstauthor))

    return authors

def recode(s):

    if isinstance(s, str):

        return s.encode(pycompat.sysstr(orig_encoding), 'replace')

    else:

        return s.decode('utf-8').encode(

            pycompat.sysstr(orig_encoding), 'replace'

        )

def mapbranch(branch, branchmap):

    """

    >>> bmap = {b'default': b'branch1'}

    >>> for i in [b'', None]:

    ...     mapbranch(i, bmap)

    'branch1'

    'branch1'

    >>> bmap = {b'None': b'branch2'}

    >>> for i in [b'', None]:

    ...     mapbranch(i, bmap)

    'branch2'

    'branch2'

    >>> bmap = {b'None': b'branch3', b'default': b'branch4'}

    >>> for i in [b'None', b'', None, b'default', b'branch5']:

    ...     mapbranch(i, bmap)

    'branch3'

    'branch4'

    'branch4'

    'branch4'

    'branch5'

    """

    # If branch is None or empty, this commit is coming from the source

    # repository's default branch and destined for the default branch in the

    # destination repository. For such commits, using a literal "default"

    # in branchmap below allows the user to map "default" to an alternate

    # default branch in the destination repository.

    branch = branchmap.get(branch or b'default', branch)

    # At some point we used "None" literal to denote the default branch,

    # attempt to use that for backward compatibility.

    if not branch:

        branch = branchmap.get(b'None', branch)

    return branch

source_converters = [

    (b'cvs', convert_cvs, b'branchsort'),

    (b'git', convert_git, b'branchsort'),

    (b'svn', svn_source, b'branchsort'),

    (b'hg', mercurial_source, b'sourcesort'),

    (b'darcs', darcs_source, b'branchsort'),

    (b'mtn', monotone_source, b'branchsort'),

    (b'gnuarch', gnuarch_source, b'branchsort'),

    (b'bzr', bzr_source, b'branchsort'),

    (b'p4', p4_source, b'branchsort'),

]

sink_converters = [

    (b'hg', mercurial_sink),

    (b'svn', svn_sink),

]

def convertsource(ui, path, type, revs):

    exceptions = []

    if type and type not in [s[0] for s in source_converters]:

        raise error.Abort(_(b'%s: invalid source repository type') % type)

    for name, source, sortmode in source_converters:

        try:

            if not type or name == type:

                return source(ui, name, path, revs), sortmode

        except (NoRepo, MissingTool) as inst:

            exceptions.append(inst)

    if not ui.quiet:

        for inst in exceptions:

            ui.write(b"%s\n" % pycompat.bytestr(inst.args[0]))

    raise error.Abort(_(b'%s: missing or unsupported repository') % path)

def convertsink(ui, path, type):

    if type and type not in [s[0] for s in sink_converters]:

        raise error.Abort(_(b'%s: invalid destination repository type') % type)

    for name, sink in sink_converters:

        try:

            if not type or name == type:

                return sink(ui, name, path)

        except NoRepo as inst:

            ui.note(_(b"convert: %s\n") % inst)

        except MissingTool as inst:

            raise error.Abort(b'%s\n' % inst)

    raise error.Abort(_(b'%s: unknown repository type') % path)

class progresssource:

    def __init__(self, ui, source, filecount):

        self.ui = ui

        self.source = source

        self.progress = ui.makeprogress(

            _(b'getting files'), unit=_(b'files'), total=filecount

        )

    def getfile(self, file, rev):

        self.progress.increment(item=file)

        return self.source.getfile(file, rev)

    def targetfilebelongstosource(self, targetfilename):

        return self.source.targetfilebelongstosource(targetfilename)

    def lookuprev(self, rev):

        return self.source.lookuprev(rev)

    def close(self):

        self.progress.complete()

# Sorters are used by the `toposort` function to maintain a set of revisions

# which can be converted immediately and pick one

class branchsorter:

    """If the previously converted revision has a child in the

    eligible revisions list, pick it. Return the list head

    otherwise. Branch sort attempts to minimize branch

    switching, which is harmful for Mercurial backend

    compression.

    """

    def __init__(self, parents):

        self.nodes = []

        self.parents = parents

        self.prev = None

    def picknext(self):

        next = self.nodes[0]

        for n in self.nodes:

            if self.prev in self.parents[n]:

                next = n

                break

        self.prev = next

        self.nodes.remove(next)

        return next

    def insert(self, node):

        self.nodes.insert(0, node)

    def __len__(self):

        return self.nodes.__len__()

class keysorter:

    """Key-based sort, ties broken by insertion order"""

    def __init__(self, keyfn):

        self.heap = []

        self.keyfn = keyfn

        self.counter = 0

    def picknext(self):

        return heapq.heappop(self.heap)[2]

    def insert(self, node):

        counter = self.counter

        self.counter = counter + 1

        key = self.keyfn(node)

        heapq.heappush(self.heap, (key, counter, node))

    def __len__(self):

        return self.heap.__len__()

class converter:

    def __init__(self, ui, source, dest, revmapfile, opts):

        self.source = source

        self.dest = dest

        self.ui = ui

        self.opts = opts

        self.commitcache = {}

        self.authors = {}

        self.authorfile = None

        # Record converted revisions persistently: maps source revision

        # ID to target revision ID (both strings).  (This is how

        # incremental conversions work.)

        self.map = mapfile(ui, revmapfile)

        # Read first the dst author map if any

        authorfile = self.dest.authorfile()

        if authorfile and os.path.exists(authorfile):

            self.readauthormap(authorfile)

        # Extend/Override with new author map if necessary

        if opts.get(b'authormap'):

            self.readauthormap(opts.get(b'authormap'))

            self.authorfile = self.dest.authorfile()

        self.splicemap = self.parsesplicemap(opts.get(b'splicemap'))

        self.branchmap = mapfile(ui, opts.get(b'branchmap'))

    def parsesplicemap(self, path):

        """check and validate the splicemap format and

        return a child/parents dictionary.

        Format checking has two parts.

        1. generic format which is same across all source types

        2. specific format checking which may be different for

           different source type.  This logic is implemented in

           checkrevformat function in source files like

           hg.py, subversion.py etc.

        """

        if not path:

            return {}

        m = {}

        try:

            fp = open(path, b'rb')

            for i, line in enumerate(fp):

                line = line.splitlines()[0].rstrip()

                if not line:

                    # Ignore blank lines

                    continue

                # split line

                lex = common.shlexer(data=line, whitespace=b',')

                line = list(lex)

                # check number of parents

                if not (2 <= len(line) <= 3):

                    raise error.Abort(

                        _(

                            b'syntax error in %s(%d): child parent1'

                            b'[,parent2] expected'

                        )

                        % (path, i + 1)

                    )

                for part in line:

                    self.source.checkrevformat(part)

                child, p1, p2 = line[0], line[1:2], line[2:]

                if p1 == p2:

                    m[child] = p1

                else:

                    m[child] = p1 + p2

        # if file does not exist or error reading, exit

        except IOError:

            raise error.Abort(

                _(b'splicemap file not found or error reading %s:') % path

            )

        return m

    def walktree(self, heads):

        """Return a mapping that identifies the uncommitted parents of every

        uncommitted changeset."""

        visit = list(heads)

        known = set()

        parents = {}

        numcommits = self.source.numcommits()

        progress = self.ui.makeprogress(

            _(b'scanning'), unit=_(b'revisions'), total=numcommits

        )

        while visit:

            n = visit.pop(0)

            if n in known:

                continue

            if n in self.map:

                m = self.map[n]

                if m == SKIPREV or self.dest.hascommitfrommap(m):

                    continue

            known.add(n)

            progress.update(len(known))

            commit = self.cachecommit(n)

            parents[n] = []

            for p in commit.parents:

                parents[n].append(p)

                visit.append(p)

        progress.complete()

        return parents

    def mergesplicemap(self, parents, splicemap):

        """A splicemap redefines child/parent relationships. Check the

        map contains valid revision identifiers and merge the new

        links in the source graph.

        """

        for c in sorted(splicemap):

            if c not in parents:

                if not self.dest.hascommitforsplicemap(self.map.get(c, c)):

                    # Could be in source but not converted during this run

                    self.ui.warn(

                        _(

                            b'splice map revision %s is not being '

                            b'converted, ignoring\n'

                        )

                        % c

                    )

                continue

            pc = []

            for p in splicemap[c]:

                # We do not have to wait for nodes already in dest.

                if self.dest.hascommitforsplicemap(self.map.get(p, p)):