class SvnWCCommandPath(FSPathBase):

def add(self):

    """ add ourself to svn """

    self._svn('add')

def blame(self):

    """ return a list of tuples of three elements:

(revision, commiter, line)"""

    out = self._svn('blame')

    result = []

    blamelines = out.splitlines()

    reallines = py.path.svnurl(self.url).readlines()

    for i, (blameline, line) in py.builtin.enumerate(

            zip(blamelines, reallines)):

        m = rex_blame.match(blameline)

        if not m:

            raise ValueError("output line %r of svn blame does not match "

                             "expected format" % (line, ))

        rev, name, _ = m.groups()

        result.append((int(rev), name, line))

    return result

def check(self, **kw):

    """ check a path for existence, or query its properties

            without arguments, this returns True if the path exists (on the

            filesystem), False if not

            with (keyword only) arguments, the object compares the value

            of the argument with the value of a property with the same name

            (if it has one, else it raises a TypeError)

            when for example the keyword argument 'ext' is '.py', this will

            return True if self.ext == '.py', False otherwise

        """

    if kw:

        kw = kw.copy()

        if not checktype(self, kw):

            return False

    else:

        kw = {'exists' : 1}

    return self.Checkers(self)._evaluate(kw)

def checkout(self, url=None, rev=None):

    """ checkout from url to local wcpath. """

    args = []

    if url is None:

        url = self.url

    if rev is None or rev == -1:

        if (py.std.sys.platform != 'win32' and

                svncommon._getsvnversion() == '1.3'):

            url += "@HEAD" 

    else:

        if svncommon._getsvnversion() == '1.3':

            url += "@%d" % rev

        else:

            args.append('-r' + str(rev))

    args.append(url)

    self._authsvn('co', args)

def cleanup(self):

    """ remove any locks from the resource """

    # XXX should be fixed properly!!!

    try:

        self.unlock()

    except:

        pass

def commit(self, msg='', rec=1):

    """ commit with support for non-recursive commits """

    from py.__.path.svn import cache

    # XXX i guess escaping should be done better here?!?

    cmd = 'commit -m "%s" --force-log' % (msg.replace('"', '\\"'),)

    if not rec:

        cmd += ' -N'

    out = self._authsvn(cmd)

    try:

        del cache.info[self]

    except KeyError:

        pass

    if out: 

        m = self._rex_commit.match(out)

        return int(m.group(1))

def common(self, other):

    """ return the common part shared with the other path

            or None if there is no common part.

        """

    last = None

    for x, y in zip(self.parts(), other.parts()):

        if x != y:

            return last

        last = x

    return last

def copy(self, target):

    """ copy path to target."""

    py.process.cmdexec("svn copy %s %s" %(str(self), str(target)))

def diff(self, rev=None):

    """ return a diff of the current path against revision rev (defaulting

            to the last one).

        """

    args = []

    if rev is not None:

        args.append("-r %d" % rev)

    out = self._authsvn('diff', args)

    return out

def dirpath(self, *args):

    """ return the directory Path of the current Path. """

    return self.__class__(self.localpath.dirpath(*args), auth=self.auth)

def dump(self, obj):

    """ pickle object into path location"""

    return self.localpath.dump(obj)

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

    """ ensure that an args-joined path exists (by default as

            a file). if you specify a keyword argument 'directory=True'

            then the path is forced  to be a directory path.

        """

    try:

        p = self.join(*args)

        if p.check():

            if p.check(versioned=False):

                p.add()

            return p 

        if kwargs.get('dir', 0):

            return p._ensuredirs()

        parent = p.dirpath()

        parent._ensuredirs()

        p.write("")

        p.add()

        return p

    except:

        error_enhance(sys.exc_info())

def info(self, usecache=1):

    """ return an Info structure with svn-provided information. """

    info = usecache and cache.info.get(self)

    if not info:

        try:

            output = self._svn('info')

        except py.process.cmdexec.Error, e:

            if e.err.find('Path is not a working copy directory') != -1:

                raise py.error.ENOENT(self, e.err)

            raise

        # XXX SVN 1.3 has output on stderr instead of stdout (while it does

        # return 0!), so a bit nasty, but we assume no output is output

        # to stderr...

        if (output.strip() == '' or 

                output.lower().find('not a versioned resource') != -1):

            raise py.error.ENOENT(self, output)

        info = InfoSvnWCCommand(output)

        # Can't reliably compare on Windows without access to win32api

        if py.std.sys.platform != 'win32': 

            if info.path != self.localpath: 

                raise py.error.ENOENT(self, "not a versioned resource:" + 

                        " %s != %s" % (info.path, self.localpath)) 

        cache.info[self] = info

    self.rev = info.rev

    return info

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

    """ return a new Path (with the same revision) which is composed

            of the self Path followed by 'args' path components.

        """

    if not args:

        return self

    localpath = self.localpath.join(*args, **kwargs)

    return self.__class__(localpath, auth=self.auth)

def listdir(self, fil=None, sort=None):

    """ return a sequence of Paths.

        listdir will return either a tuple or a list of paths

        depending on implementation choices.

        """

    if isinstance(fil, str):

        fil = common.fnmatch(fil)

    # XXX unify argument naming with LocalPath.listdir

    def notsvn(path):

        return path.basename != '.svn' 

    paths = []

    for localpath in self.localpath.listdir(notsvn):

        p = self.__class__(localpath, auth=self.auth)

        paths.append(p)

    if fil or sort:

        paths = filter(fil, paths)

        paths = isinstance(paths, list) and paths or list(paths)

        if callable(sort):

            paths.sort(sort)

        elif sort:

            paths.sort()

    return paths

def load(self):

    """ return object unpickled from self.read() """

    f = self.open('rb')

    try:

        from cPickle import load

        return self._callex(load, f)

    finally:

        f.close()

def lock(self):

    """ set a lock (exclusive) on the resource """

    out = self._authsvn('lock').strip()

    if not out:

        # warning or error, raise exception

        raise Exception(out[4:])

def log(self, rev_start=None, rev_end=1, verbose=False):

    """ return a list of LogEntry instances for this path.

rev_start is the starting revision (defaulting to the first one).

rev_end is the last revision (defaulting to HEAD).

if verbose is True, then the LogEntry instances also know which files changed.

"""

    from py.__.path.svn.urlcommand import _Head, LogEntry

    assert self.check()   # make it simpler for the pipe

    rev_start = rev_start is None and _Head or rev_start

    rev_end = rev_end is None and _Head or rev_end

    if rev_start is _Head and rev_end == 1:

            rev_opt = ""

    else:

        rev_opt = "-r %s:%s" % (rev_start, rev_end)

    verbose_opt = verbose and "-v" or ""

    locale_env = svncommon.fixlocale()

    # some blather on stderr

    auth_opt = self._makeauthoptions()

    stdin, stdout, stderr  = os.popen3(locale_env +

                                       'svn log --xml %s %s %s "%s"' % (

                                        rev_opt, verbose_opt, auth_opt,

                                        self.strpath))

    from xml.dom import minidom

    from xml.parsers.expat import ExpatError

    try:

        tree = minidom.parse(stdout)

    except ExpatError:

        # XXX not entirely sure about this exception... shouldn't it be

        # some py.error.* something?

        raise ValueError('no such revision')

    result = []

    for logentry in filter(None, tree.firstChild.childNodes):

        if logentry.nodeType == logentry.ELEMENT_NODE:

            result.append(LogEntry(logentry))

    return result

def mkdir(self, *args):

    """ create & return the directory joined with args. """

    if args:

        return self.join(*args).mkdir()

    else:

        self._svn('mkdir')

        return self

def move(self, target):

    """ move this path to target. """

    if target.relto(self):

        raise py.error.EINVAL(target, "cannot move path into a subdirectory of itself")

    try:

        self.rename(target)

    except py.error.EXDEV:  # invalid cross-device link

        self.copy(target)

        self.remove()

def mtime(self):

    """ Return the last modification time of the file. """

    return self.info().mtime

def new(self, **kw):

    """ create a modified version of this path. A 'rev' argument

            indicates a new revision.

            the following keyword arguments modify various path parts:

              http://host.com/repo/path/file.ext

              |-----------------------|          dirname

                                        |------| basename

                                        |--|     purebasename