# git.py - git support for the 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.

from __future__ import absolute_import

import os

from mercurial.i18n import _

from mercurial import (

    config,

    error,

    node as nodemod,

    pycompat,

)

from . import common

class submodule(object):

    def __init__(self, path, node, url):

        self.path = path

        self.node = node

        self.url = url

    def hgsub(self):

        return b"%s = [git]%s" % (self.path, self.url)

    def hgsubstate(self):

        return b"%s %s" % (self.node, self.path)

# Keys in extra fields that should not be copied if the user requests.

bannedextrakeys = {

    # Git commit object built-ins.

    b'tree',

    b'parent',

    b'author',

    b'committer',

    # Mercurial built-ins.

    b'branch',

    b'close',

}

class convert_git(common.converter_source, common.commandline):

    # Windows does not support GIT_DIR= construct while other systems

    # cannot remove environment variable. Just assume none have

    # both issues.

    def _gitcmd(self, cmd, *args, **kwargs):

        return cmd(b'--git-dir=%s' % self.path, *args, **kwargs)

    def gitrun0(self, *args, **kwargs):

        return self._gitcmd(self.run0, *args, **kwargs)

    def gitrun(self, *args, **kwargs):

        return self._gitcmd(self.run, *args, **kwargs)

    def gitrunlines0(self, *args, **kwargs):

        return self._gitcmd(self.runlines0, *args, **kwargs)

    def gitrunlines(self, *args, **kwargs):

        return self._gitcmd(self.runlines, *args, **kwargs)

    def gitpipe(self, *args, **kwargs):

        return self._gitcmd(self._run3, *args, **kwargs)

    def __init__(self, ui, repotype, path, revs=None):

        super(convert_git, self).__init__(ui, repotype, path, revs=revs)

        common.commandline.__init__(self, ui, b'git')

        # Pass an absolute path to git to prevent from ever being interpreted

        # as a URL

        path = os.path.abspath(path)

        if os.path.isdir(path + b"/.git"):

            path += b"/.git"

        if not os.path.exists(path + b"/objects"):

            raise common.NoRepo(

                _(b"%s does not look like a Git repository") % path

            )

        # The default value (50) is based on the default for 'git diff'.

        similarity = ui.configint(b'convert', b'git.similarity')

        if similarity < 0 or similarity > 100:

            raise error.Abort(_(b'similarity must be between 0 and 100'))

        if similarity > 0:

            self.simopt = [b'-C%d%%' % similarity]

            findcopiesharder = ui.configbool(

                b'convert', b'git.findcopiesharder'

            )

            if findcopiesharder:

                self.simopt.append(b'--find-copies-harder')

            renamelimit = ui.configint(b'convert', b'git.renamelimit')

            self.simopt.append(b'-l%d' % renamelimit)

        else:

            self.simopt = []

        common.checktool(b'git', b'git')

        self.path = path

        self.submodules = []

        self.catfilepipe = self.gitpipe(b'cat-file', b'--batch')

        self.copyextrakeys = self.ui.configlist(b'convert', b'git.extrakeys')

        banned = set(self.copyextrakeys) & bannedextrakeys

        if banned:

            raise error.Abort(

                _(b'copying of extra key is forbidden: %s')

                % _(b', ').join(sorted(banned))

            )

        committeractions = self.ui.configlist(

            b'convert', b'git.committeractions'

        )

        messagedifferent = None

        messagealways = None

        for a in committeractions:

            if a.startswith((b'messagedifferent', b'messagealways')):

                k = a

                v = None

                if b'=' in a:

                    k, v = a.split(b'=', 1)

                if k == b'messagedifferent':

                    messagedifferent = v or b'committer:'

                elif k == b'messagealways':

                    messagealways = v or b'committer:'

        if messagedifferent and messagealways:

            raise error.Abort(

                _(

                    b'committeractions cannot define both '

                    b'messagedifferent and messagealways'

                )

            )

        dropcommitter = b'dropcommitter' in committeractions

        replaceauthor = b'replaceauthor' in committeractions

        if dropcommitter and replaceauthor:

            raise error.Abort(

                _(

                    b'committeractions cannot define both '

                    b'dropcommitter and replaceauthor'

                )

            )

        if dropcommitter and messagealways:

            raise error.Abort(

                _(

                    b'committeractions cannot define both '

                    b'dropcommitter and messagealways'

                )

            )

        if not messagedifferent and not messagealways:

            messagedifferent = b'committer:'

        self.committeractions = {

            b'dropcommitter': dropcommitter,

            b'replaceauthor': replaceauthor,

            b'messagedifferent': messagedifferent,

            b'messagealways': messagealways,

        }

    def after(self):

        for f in self.catfilepipe:

            f.close()

    def getheads(self):

        if not self.revs:

            output, status = self.gitrun(

                b'rev-parse', b'--branches', b'--remotes'

            )

            heads = output.splitlines()

            if status:

                raise error.Abort(_(b'cannot retrieve git heads'))

        else:

            heads = []

            for rev in self.revs:

                rawhead, ret = self.gitrun(b'rev-parse', b'--verify', rev)

                heads.append(rawhead[:-1])

                if ret:

                    raise error.Abort(_(b'cannot retrieve git head "%s"') % rev)

        return heads

    def catfile(self, rev, ftype):

        if rev == nodemod.nullhex:

            raise IOError

        self.catfilepipe[0].write(rev + b'\n')

        self.catfilepipe[0].flush()

        info = self.catfilepipe[1].readline().split()

        if info[1] != ftype:

            raise error.Abort(

                _(b'cannot read %r object at %s')

                % (pycompat.bytestr(ftype), rev)

            )

        size = int(info[2])

        data = self.catfilepipe[1].read(size)

        if len(data) < size:

            raise error.Abort(

                _(b'cannot read %r object at %s: unexpected size')

                % (ftype, rev)

            )

        # read the trailing newline

        self.catfilepipe[1].read(1)

        return data

    def getfile(self, name, rev):

        if rev == nodemod.nullhex:

            return None, None

        if name == b'.hgsub':

            data = b'\n'.join([m.hgsub() for m in self.submoditer()])

            mode = b''

        elif name == b'.hgsubstate':

            data = b'\n'.join([m.hgsubstate() for m in self.submoditer()])

            mode = b''

        else:

            data = self.catfile(rev, b"blob")

            mode = self.modecache[(name, rev)]

        return data, mode

    def submoditer(self):

        null = nodemod.nullhex

        for m in sorted(self.submodules, key=lambda p: p.path):

            if m.node != null:

                yield m

    def parsegitmodules(self, content):

        """Parse the formatted .gitmodules file, example file format:

        [submodule "sub"]\n

        \tpath = sub\n

        \turl = git://giturl\n

        """

        self.submodules = []

        c = config.config()

        # Each item in .gitmodules starts with whitespace that cant be parsed

        c.parse(

            b'.gitmodules',

            b'\n'.join(line.strip() for line in content.split(b'\n')),

        )

        for sec in c.sections():

            s = c[sec]

            if b'url' in s and b'path' in s:

                self.submodules.append(submodule(s[b'path'], b'', s[b'url']))

    def retrievegitmodules(self, version):

        modules, ret = self.gitrun(

            b'show', b'%s:%s' % (version, b'.gitmodules')

        )

        if ret:

            # This can happen if a file is in the repo that has permissions

            # 160000, but there is no .gitmodules file.

            self.ui.warn(

                % version

            )

            return

        try:

            self.parsegitmodules(modules)

        except error.ParseError:

            self.ui.warn(

                _(b"warning: unable to parse .gitmodules in %s\n") % version

            )

            return

        for m in self.submodules:

            node, ret = self.gitrun(b'rev-parse', b'%s:%s' % (version, m.path))

            if ret:

                continue

            m.node = node.strip()

    def getchanges(self, version, full):

        if full:

            raise error.Abort(_(b"convert from git does not support --full"))

        self.modecache = {}

        cmd = (

            [b'diff-tree', b'-z', b'--root', b'-m', b'-r']

            + self.simopt

            + [version]

        )

        output, status = self.gitrun(*cmd)

        if status:

            raise error.Abort(_(b'cannot read changes in %s') % version)

        changes = []

        copies = {}

        seen = set()

        entry = None

        subexists = [False]

        subdeleted = [False]

        difftree = output.split(b'\x00')

        lcount = len(difftree)

        i = 0

        skipsubmodules = self.ui.configbool(b'convert', b'git.skipsubmodules')

        def add(entry, f, isdest):

            seen.add(f)

            h = entry[3]

            p = entry[1] == b"100755"

            s = entry[1] == b"120000"

            renamesource = not isdest and entry[4][0] == b'R'

            if f == b'.gitmodules':

                if skipsubmodules:

                    return

                subexists[0] = True

                if entry[4] == b'D' or renamesource:

                    subdeleted[0] = True

                    changes.append((b'.hgsub', nodemod.nullhex))

                else:

                    changes.append((b'.hgsub', b''))

            elif entry[1] == b'160000' or entry[0] == b':160000':

                if not skipsubmodules:

                    subexists[0] = True

            else:

                if renamesource:

                    h = nodemod.nullhex

                self.modecache[(f, h)] = (p and b"x") or (s and b"l") or b""

                changes.append((f, h))

        while i < lcount:

            l = difftree[i]

            i += 1

            if not entry:

                if not l.startswith(b':'):

                    continue

                entry = tuple(pycompat.bytestr(p) for p in l.split())

                continue

            f = l

            if entry[4][0] == b'C':

                copysrc = f

                copydest = difftree[i]

                i += 1

                f = copydest

                copies[copydest] = copysrc

            if f not in seen:

                add(entry, f, False)

            # A file can be copied multiple times, or modified and copied

            # simultaneously. So f can be repeated even if fdest isn't.

            if entry[4][0] == b'R':

                # rename: next line is the destination

                fdest = difftree[i]

                i += 1

                if fdest not in seen:

                    add(entry, fdest, True)

                    # .gitmodules isn't imported at all, so it being copied to

                    # and fro doesn't really make sense

                    if f != b'.gitmodules' and fdest != b'.gitmodules':

                        copies[fdest] = f

            entry = None

        if subexists[0]: