# Subversion 1.4/1.5 Python API backend

#

# Copyright(C) 2007 Daniel Holth et al

import os, re, sys, tempfile, urllib, urllib2, xml.dom.minidom

import cPickle as pickle

from mercurial import strutil, scmutil, util, encoding

from mercurial.i18n import _

propertycache = util.propertycache

# 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, MissingTool, commit, encodeargs, decodeargs

from common import commandline, converter_source, 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

    import warnings

    warnings.filterwarnings('ignore',

            module='svn.core',

            category=DeprecationWarning)

except ImportError:

    svn = None

class SvnPathNotFound(Exception):

    pass

def revsplit(rev):

    """Parse a revision string and return (uuid, path, revnum)."""

    url, revnum = rev.rsplit('@', 1)

    parts = url.split('/', 1)

    mod = ''

    if len(parts) > 1:

        mod = '/' + parts[1]

    return parts[0][4:], mod, int(revnum)

def quote(s):

    # As of svn 1.7, many svn calls expect "canonical" paths. In

    # theory, we should call svn.core.*canonicalize() on all paths

    # before passing them to the API.  Instead, we assume the base url

    # is canonical and copy the behaviour of svn URL encoding function

    # so we can extend it safely with new components. The "safe"

    # characters were taken from the "svn_uri__char_validity" table in

    # libsvn_subr/path.c.

    return urllib.quote(s, "!$&'()*+,-./:=@_~")

def geturl(path):

    try:

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

    except SubversionException:

        # svn.client.url_from_path() fails with local repositories

        pass

    if os.path.isdir(path):

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

        if os.name == 'nt':

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

        # Module URL is later compared with the repository URL returned

        # by svn API, which is UTF-8.

        path = encoding.tolocal(path)

        path = 'file://%s' % quote(path)

    return svn.core.svn_path_canonicalize(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 IOError:

        # Caller may interrupt the iteration

        pickle.dump(None, fp, protocol)

    except Exception, inst:

        pickle.dump(str(inst), 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.setbinary(sys.stdin)

    util.setbinary(sys.stdout)

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

    get_log_child(sys.stdout, *args)

class logstream(object):

    """Interruptible revision log iterator."""

    def __init__(self, stdout):

        self._stdout = stdout

    def __iter__(self):

        while True:

            try:

                entry = pickle.load(self._stdout)

            except EOFError:

                raise util.Abort(_('Mercurial failed to run itself, check'

                                   ' hg executable is in PATH'))

            try:

                orig_paths, revnum, author, date, message = entry

                if entry is None:

                    break

                raise util.Abort(_("log stream exception '%s'") % entry)

            yield entry

    def close(self):

        if self._stdout:

            self._stdout.close()

            self._stdout = None

# Check to see if the given path is a local Subversion repo. Verify this by

# looking for several svn-specific files and directories in the given

# directory.

def filecheck(ui, path, proto):

    for x in ('locks', 'hooks', 'format', 'db'):

        if not os.path.exists(os.path.join(path, x)):

            return False

    return True

# Check to see if a given path is the root of an svn repo over http. We verify

# this by requesting a version-controlled URL we know can't exist and looking

# for the svn-specific "not found" XML.

def httpcheck(ui, path, proto):

    try:

        opener = urllib2.build_opener()

        rsp = opener.open('%s://%s/!svn/ver/0/.svn' % (proto, path))

        data = rsp.read()

    except urllib2.HTTPError, inst:

        if inst.code != 404:

            # Except for 404 we cannot know for sure this is not an svn repo

            ui.warn(_('svn: cannot probe remote repository, assume it could '

                      'be a subversion repository. Use --source-type if you '

                      'know better.\n'))

            return True

        data = inst.fp.read()

    except:

        # Could be urllib2.URLError if the URL is invalid or anything else.

        return False

    return '<m:human-readable errcode="160013">' in data

protomap = {'http': httpcheck,

            'https': httpcheck,

            'file': filecheck,

            }

def issvnurl(ui, url):

    try:

        proto, path = url.split('://', 1)

        if proto == 'file':

            path = urllib.url2pathname(path)

    except ValueError:

        proto = 'file'

        path = os.path.abspath(url)

    if proto == 'file':

        path = util.pconvert(path)

    check = protomap.get(proto, lambda *args: False)

    while '/' in path:

        if check(ui, path, proto):

            return True

        path = path.rsplit('/', 1)[0]

    return False

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

        if not (url.startswith('svn://') or url.startswith('svn+ssh://') or

                (os.path.exists(url) and

                 os.path.exists(os.path.join(url, '.svn'))) or

                issvnurl(ui, url)):

            raise NoRepo(_("%s does not look like a Subversion repository")

                         % url)

        if svn is None:

            raise MissingTool(_('Could not load Subversion python bindings'))

        try:

            version = svn.core.SVN_VER_MAJOR, svn.core.SVN_VER_MINOR

            if version < (1, 4):

                raise MissingTool(_('Subversion python bindings %d.%d found, '

                                    '1.4 or later required') % version)

        except AttributeError:

            raise MissingTool(_('Subversion python bindings are too old, 1.4 '

                                'or later required'))

        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:

            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.baseurl = 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 = urllib.unquote(self.url[len(self.baseurl):])

            self.prevmodule = None

            self.rootmodule = self.module

            self.commits = {}

            self.paths = {}

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

        except SubversionException:

            ui.traceback()

            raise NoRepo(_("%s does not look like a Subversion repository")

                         % self.url)

        if rev:

            try:

                latest = int(rev)

            except ValueError:

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

        self.trunkname = self.ui.config('convert', 'svn.trunk',

                                        'trunk').strip('/')

        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.head = self.latest(self.module, latest)

        except SvnPathNotFound:

            self.head = None

        if not self.head:

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

                             % self.module)

        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 = 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('/') + '/' + quote(path),

                                 optrev, False, self.ctx)

            return True

        except SubversionException:

            return False

    def getheads(self):

        def isdir(path, revnum):

            kind = self._checkpath(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 self.module.endswith(path) and name == 'trunk':

                    # we are converting from inside this directory

                    return None

                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)

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