# Subversion 1.4/1.5 Python API backend

#

# Copyright(C) 2007 Daniel Holth et al

#

# Configuration options:

#

# convert.svn.trunk

#   Relative path to the trunk (default: "trunk")

# convert.svn.branches

#   Relative path to tree of branches (default: "branches")

# convert.svn.tags

#   Relative path to tree of tags (default: "tags")

#

# Set these in a hgrc, or on the command line as follows:

#

#   hg convert --config convert.svn.trunk=wackoname [...]

import locale

import os

import re

import sys

import cPickle as pickle

import tempfile

from mercurial import strutil, util

from mercurial.i18n import _

# Subversion stuff. Works best with very recent Python SVN bindings

# e.g. SVN 1.5 or backports. Thanks to the bzr folks for enhancing

# these bindings.

from cStringIO import StringIO

from common import NoRepo, commit, converter_source, encodeargs, decodeargs

from common import commandline, converter_sink, mapfile

try:

    from svn.core import SubversionException, Pool

    import svn

    import svn.client

    import svn.core

    import svn.ra

    import svn.delta

    import transport

except ImportError:

    pass

def geturl(path):

    try:

        return svn.client.url_from_path(svn.core.svn_path_canonicalize(path))

    except SubversionException:

        pass

    if os.path.isdir(path):

        path = os.path.normpath(os.path.abspath(path))

        if os.name == 'nt':

            path = '/' + util.normpath(path)

        return 'file://%s' % path

    return path

def optrev(number):

    optrev = svn.core.svn_opt_revision_t()

    optrev.kind = svn.core.svn_opt_revision_number

    optrev.value.number = number

    return optrev

class changedpath(object):

    def __init__(self, p):

        self.copyfrom_path = p.copyfrom_path

        self.copyfrom_rev = p.copyfrom_rev

        self.action = p.action

def get_log_child(fp, url, paths, start, end, limit=0, discover_changed_paths=True,

                    strict_node_history=False):

    protocol = -1

    def receiver(orig_paths, revnum, author, date, message, pool):

        if orig_paths is not None:

            for k, v in orig_paths.iteritems():

                orig_paths[k] = changedpath(v)

        pickle.dump((orig_paths, revnum, author, date, message),

                    fp, protocol)

    try:

        # Use an ra of our own so that our parent can consume

        # our results without confusing the server.

        t = transport.SvnRaTransport(url=url)

        svn.ra.get_log(t.ra, paths, start, end, limit,

                       discover_changed_paths,

                       strict_node_history,

                       receiver)

    except SubversionException, (inst, num):

        pickle.dump(num, fp, protocol)

    except IOError:

        # Caller may interrupt the iteration

        pickle.dump(None, fp, protocol)

    else:

        pickle.dump(None, fp, protocol)

    fp.close()

    # With large history, cleanup process goes crazy and suddenly

    # consumes *huge* amount of memory. The output file being closed,

    # there is no need for clean termination.

    os._exit(0)

def debugsvnlog(ui, **opts):

    """Fetch SVN log in a subprocess and channel them back to parent to

    avoid memory collection issues.

    """

    util.set_binary(sys.stdin)

    util.set_binary(sys.stdout)

    args = decodeargs(sys.stdin.read())

    get_log_child(sys.stdout, *args)

class logstream:

    """Interruptible revision log iterator."""

    def __init__(self, stdout):

        self._stdout = stdout

    def __iter__(self):

        while True:

            entry = pickle.load(self._stdout)

            try:

                orig_paths, revnum, author, date, message = entry

            except:

                if entry is None:

                    break

                raise SubversionException("child raised exception", entry)

            yield entry

    def close(self):

        if self._stdout:

            self._stdout.close()

            self._stdout = None

def get_log(url, paths, start, end, limit=0, discover_changed_paths=True,

                strict_node_history=False):

    args = [url, paths, start, end, limit, discover_changed_paths,

            strict_node_history]

    arg = encodeargs(args)

    hgexe = util.hgexecutable()

    cmd = '%s debugsvnlog' % util.shellquote(hgexe)

    stdin, stdout = os.popen2(cmd, 'b')

    stdin.write(arg)

    stdin.close()

    return logstream(stdout)

# SVN conversion code stolen from bzr-svn and tailor

#

# Subversion looks like a versioned filesystem, branches structures

# are defined by conventions and not enforced by the tool. First,

# we define the potential branches (modules) as "trunk" and "branches"

# children directories. Revisions are then identified by their

# module and revision number (and a repository identifier).

#

# The revision graph is really a tree (or a forest). By default, a

# revision parent is the previous revision in the same module. If the

# module directory is copied/moved from another module then the

# revision is the module root and its parent the source revision in

# the parent module. A revision has at most one parent.

#

class svn_source(converter_source):

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

        super(svn_source, self).__init__(ui, url, rev=rev)

        try:

            SubversionException

        except NameError:

            raise NoRepo('Subversion python bindings could not be loaded')

        self.encoding = locale.getpreferredencoding()

        self.lastrevs = {}

        latest = None

        try:

            # Support file://path@rev syntax. Useful e.g. to convert

            # deleted branches.

            at = url.rfind('@')

            if at >= 0:

                latest = int(url[at+1:])

                url = url[:at]

        except ValueError, e:

            pass

        self.url = geturl(url)

        self.encoding = 'UTF-8' # Subversion is always nominal UTF-8

        try:

            self.transport = transport.SvnRaTransport(url=self.url)

            self.ra = self.transport.ra

            self.ctx = self.transport.client

            self.base = svn.ra.get_repos_root(self.ra)

            # Module is either empty or a repository path starting with

            # a slash and not ending with a slash.

            self.module = self.url[len(self.base):]

            self.rootmodule = self.module

            self.commits = {}

            self.paths = {}

            self.uuid = svn.ra.get_uuid(self.ra).decode(self.encoding)

        except SubversionException, e:

            ui.print_exc()

            raise NoRepo("%s does not look like a Subversion repo" % self.url)

        if rev:

            try:

                latest = int(rev)

            except ValueError:

                raise util.Abort('svn: revision %s is not an integer' % rev)

        self.startrev = self.ui.config('convert', 'svn.startrev', default=0)

        try:

            self.startrev = int(self.startrev)

            if self.startrev < 0:

                self.startrev = 0

        except ValueError:

            raise util.Abort(_('svn: start revision %s is not an integer')

                             % self.startrev)

        try:

            self.get_blacklist()

        except IOError, e:

            pass

        self.head = self.latest(self.module, latest)

        if not self.head:

            raise util.Abort(_('no revision found in module %s') %

                             self.module.encode(self.encoding))

        self.last_changed = self.revnum(self.head)

        self._changescache = None

        if os.path.exists(os.path.join(url, '.svn/entries')):

            self.wc = url

        else:

            self.wc = None

        self.convertfp = None

    def setrevmap(self, revmap):

        lastrevs = {}

        for revid in revmap.iterkeys():

            uuid, module, revnum = self.revsplit(revid)

            lastrevnum = lastrevs.setdefault(module, revnum)

            if revnum > lastrevnum:

                lastrevs[module] = revnum

        self.lastrevs = lastrevs

    def exists(self, path, optrev):

        try:

            svn.client.ls(self.url.rstrip('/') + '/' + path,

                                 optrev, False, self.ctx)

            return True

        except SubversionException, err:

            return False

    def getheads(self):

        def isdir(path, revnum):

            kind = svn.ra.check_path(self.ra, path, revnum)

            return kind == svn.core.svn_node_dir

        def getcfgpath(name, rev):

            cfgpath = self.ui.config('convert', 'svn.' + name)

            if cfgpath is not None and cfgpath.strip() == '':

                return None

            path = (cfgpath or name).strip('/')

            if not self.exists(path, rev):

                if cfgpath:

                    raise util.Abort(_('expected %s to be at %r, but not found')

                                 % (name, path))

                return None

            self.ui.note(_('found %s at %r\n') % (name, path))

            return path

        rev = optrev(self.last_changed)

        oldmodule = ''

        trunk = getcfgpath('trunk', rev)

        self.tags = getcfgpath('tags', rev)

        branches = getcfgpath('branches', rev)

        # If the project has a trunk or branches, we will extract heads

        # from them. We keep the project root otherwise.

        if trunk:

            oldmodule = self.module or ''

            self.module += '/' + trunk

            self.head = self.latest(self.module, self.last_changed)

            if not self.head:

                raise util.Abort(_('no revision found in module %s') %

                                 self.module.encode(self.encoding))

        # First head in the list is the module's head

        self.heads = [self.head]

        if self.tags is not None:

            self.tags = '%s/%s' % (oldmodule , (self.tags or 'tags'))

        # Check if branches bring a few more heads to the list

        if branches:

            rpath = self.url.strip('/')

            branchnames = svn.client.ls(rpath + '/' + branches, rev, False,

                                        self.ctx)

            for branch in branchnames.keys():

                module = '%s/%s/%s' % (oldmodule, branches, branch)

                if not isdir(module, self.last_changed):

                    continue

                brevid = self.latest(module, self.last_changed)

                if not brevid:

                    self.ui.note(_('ignoring empty branch %s\n') %

                                   branch.encode(self.encoding))

                    continue

                self.ui.note('found branch %s at %d\n' %

                             (branch, self.revnum(brevid)))

                self.heads.append(brevid)

        if self.startrev and self.heads:

            if len(self.heads) > 1:

                raise util.Abort(_('svn: start revision is not supported with '

                                   'with more than one branch'))

            revnum = self.revnum(self.heads[0])

            if revnum < self.startrev:

                raise util.Abort(_('svn: no revision found after start revision %d')

                                 % self.startrev)

        return self.heads

    def getfile(self, file, rev):

        data, mode = self._getfile(file, rev)

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

        return data

    def getmode(self, file, rev):

        return self.modecache[(file, rev)]

    def getchanges(self, rev):

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

            return self._changescache[1]

        self._changescache = None

        self.modecache = {}

        (paths, parents) = self.paths[rev]

        if parents:

            files, copies = self.expandpaths(rev, paths, parents)

        else:

            # Perform a full checkout on roots

            uuid, module, revnum = self.revsplit(rev)

            entries = svn.client.ls(self.base + module, optrev(revnum),

                                    True, self.ctx)

            files = [n for n,e in entries.iteritems()

                     if e.kind == svn.core.svn_node_file]

            copies = {}

        files.sort()

        files = zip(files, [rev] * len(files))

        # caller caches the result, so free it here to release memory

        del self.paths[rev]

        return (files, copies)

    def getchangedfiles(self, rev, i):

        changes = self.getchanges(rev)

        self._changescache = (rev, changes)

        return [f[0] for f in changes[0]]

    def getcommit(self, rev):

        if rev not in self.commits:

            uuid, module, revnum = self.revsplit(rev)

            self.module = module

            self.reparent(module)

            # We assume that:

            # - requests for revisions after "stop" come from the

            # revision graph backward traversal. Cache all of them

            # down to stop, they will be used eventually.

            # - requests for revisions before "stop" come to get

            # isolated branches parents. Just fetch what is needed.