# darcs.py - darcs support for the convert extension

#

#  Copyright 2007-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 errno

import os

import re

import shutil

from mercurial.i18n import _

from mercurial import (

    error,

    pycompat,

    util,

)

from mercurial.utils import dateutil

from . import common

NoRepo = common.NoRepo

# The naming drift of ElementTree is fun!

try:

    import xml.etree.cElementTree.ElementTree as ElementTree

    import xml.etree.cElementTree.XMLParser as XMLParser

except ImportError:

    try:

        import xml.etree.ElementTree.ElementTree as ElementTree

        import xml.etree.ElementTree.XMLParser as XMLParser

    except ImportError:

        try:

            import elementtree.cElementTree.ElementTree as ElementTree

            import elementtree.cElementTree.XMLParser as XMLParser

        except ImportError:

            try:

                import elementtree.ElementTree.ElementTree as ElementTree

                import elementtree.ElementTree.XMLParser as XMLParser

            except ImportError:

                pass

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

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

        common.converter_source.__init__(self, ui, repotype, path, revs=revs)

        # check for _darcs, ElementTree so that we can easily skip

        # test-convert-darcs if ElementTree is not around

            raise error.Abort(

            )

        self.path = os.path.realpath(path)

        self.lastrev = None

        self.changes = {}

        self.parents = {}

        self.tags = {}

        # Check darcs repository format

        format = self.format()

        if format:

                raise NoRepo(

                    % format

                )

        else:

    def before(self):

        self.tmppath = pycompat.mkdtemp(

        )

        self.checkexit(status)

        tree = self.xml(

        )

        tagname = None

        child = None

                tagname = name[4:].strip()

            elif tagname is not None:

                self.tags[tagname] = node

                tagname = None

            self.changes[node] = elt

            self.parents[child] = [node]

            child = node

        self.parents[child] = []

    def after(self):

        shutil.rmtree(self.tmppath, ignore_errors=True)

    def recode(self, s, encoding=None):

        if isinstance(s, pycompat.unicode):

            # XMLParser returns unicode objects for anything it can't

            # encode into ASCII. We convert them back to str to get

            # recode's normal conversion behavior.

            s = s.encode('latin-1')

        return super(darcs_source, self).recode(s, encoding)

    def xml(self, cmd, **kwargs):

        # NOTE: darcs is currently encoding agnostic and will print

        # patch metadata byte-for-byte, even in the XML changelog.

        etree = ElementTree()

        # While we are decoding the XML as latin-1 to be as liberal as

        # possible, etree will still raise an exception if any

        # non-printable characters are in the XML changelog.

        p = self._run(cmd, **kwargs)

        etree.parse(p.stdout, parser=parser)

        p.wait()

        self.checkexit(p.returncode)

        return etree.getroot()

    def format(self):

        self.checkexit(status)

        m = re.search(r'^\s*Format:\s*(.*)$', output, re.MULTILINE)

        if not m:

            return None

    def manifest(self):

        man = []

        output, status = self.run(

        )

        self.checkexit(status)

            path = line[2:]

            if path:

                man.append(path)

        return man

    def getheads(self):

        return self.parents[None]

    def getcommit(self, rev):

        elt = self.changes[rev]

        # etree can return unicode objects for name, comment, and author,

        # so recode() is used to ensure str objects are emitted.

        return common.commit(

            date=dateutil.datestr(date, newdateformat),

            desc=self.recode(desc).strip(),

            parents=self.parents[rev],

        )

    def pull(self, rev):

        output, status = self.run(

            self.path,

            all=True,

            no_test=True,

            no_posthook=True,

            repodir=self.tmppath,

        )

        if status:

                self.checkexit(status, output)

            self.checkexit(status, output)

    def getchanges(self, rev, full):

        if full:

        copies = {}

        changes = []

        man = None

                continue

                if man is None:

                    man = self.manifest()

                if source in man:

                    # File move

                    changes.append((source, rev))

                    changes.append((dest, rev))

                    copies[dest] = source

                else:

                    # Directory move, deduce file moves from manifest

                    for f in man:

                        if not f.startswith(source):

                            continue

                        changes.append((f, rev))

                        changes.append((fdest, rev))

                        copies[fdest] = f

            else:

                changes.append((elt.text.strip(), rev))

        self.pull(rev)

        self.lastrev = rev

        return sorted(changes), copies, set()

    def getfile(self, name, rev):

        if rev != self.lastrev:

        path = os.path.join(self.tmppath, name)

        try:

            data = util.readfile(path)

            mode = os.lstat(path).st_mode

        except IOError as inst:

            if inst.errno == errno.ENOENT:

                return None, None

            raise

        return data, mode

    def gettags(self):

        return self.tags