class SvnCommandPath(SvnPathBase):

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 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, msg='copied by py lib invocation'):

    """ copy path to target with checkin message msg."""

    if getattr(target, 'rev', None) is not None:

        raise py.error.EINVAL(target, "revisions are immutable")

    self._svncmdexecauth('svn copy -m "%s" "%s" "%s"' %(msg,

                         self._escape(self), self._escape(target)))

    self._norev_delentry(target.dirpath())

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

    """ return the directory path of the current path joined

            with any given path arguments.

        """

    l = self.strpath.split(self.sep) 

    if len(l) < 4: 

        raise py.error.EINVAL(self, "base is not valid") 

    elif len(l) == 4: 

        return self.join(*args, **kwargs) 

    else: 

        return self.new(basename='').join(*args, **kwargs)

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

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

            a file). If you specify a keyword argument 'dir=True'

            then the path is forced to be a directory path.

        """

    if getattr(self, 'rev', None) is not None:

        raise py.error.EINVAL(self, "revisions are immutable")

    target = self.join(*args)

    dir = kwargs.get('dir', 0) 

    for x in target.parts(reverse=True): 

        if x.check(): 

            break 

    else: 

        raise py.error.ENOENT(target, "has not any valid base!") 

    if x == target: 

        if not x.check(dir=dir): 

            raise dir and py.error.ENOTDIR(x) or py.error.EISDIR(x) 

        return x 

    tocreate = target.relto(x) 

    basename = tocreate.split(self.sep, 1)[0]

    tempdir = py.path.local.mkdtemp()

    try:    

        tempdir.ensure(tocreate, dir=dir) 

        cmd = 'svn import -m "%s" "%s" "%s"' % (

                "ensure %s" % self._escape(tocreate), 

                self._escape(tempdir.join(basename)), 

                x.join(basename)._encodedurl())

        self._svncmdexecauth(cmd) 

        self._norev_delentry(x)

    finally:    

        tempdir.remove() 

    return target

def export(self, topath):

    """ export to a local path

            topath should not exist prior to calling this, returns a

            py.path.local instance

        """

    topath = py.path.local(topath)

    args = ['"%s"' % (self._escape(self),),

            '"%s"' % (self._escape(topath),)]

    if self.rev is not None:

        args = ['-r', str(self.rev)] + args

    self._svncmdexecauth('svn export %s' % (' '.join(args),))

    return topath

def info(self):

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

    parent = self.dirpath()

    nameinfo_seq = parent._listdir_nameinfo()

    bn = self.basename

    for name, info in nameinfo_seq:

        if name == bn:

            return info

    raise py.error.ENOENT(self)

def join(self, *args):

    """ 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

    args = tuple([arg.strip(self.sep) for arg in args])

    parts = (self.strpath, ) + args

    newpath = self.__class__(self.sep.join(parts), self.rev, self.auth)

    return newpath

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

    """ list directory contents, possibly filter by the given fil func

            and possibly sorted.

        """

    if isinstance(fil, str):

        fil = common.fnmatch(fil)

    nameinfo_seq = self._listdir_nameinfo()

    if len(nameinfo_seq) == 1:

        name, info = nameinfo_seq[0]

        if name == self.basename and info.kind == 'file':

            #if not self.check(dir=1):

            raise py.error.ENOTDIR(self)

    paths = self._make_path_tuple(nameinfo_seq)

    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 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.

"""

    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 ""

    xmlpipe =  self._svnpopenauth('svn log --xml %s %s "%s"' %

                                  (rev_opt, verbose_opt, self.strpath))

    from xml.dom import minidom

    tree = minidom.parse(xmlpipe)

    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, **kwargs):

    """ create & return the directory joined with args. You can provide

a checkin message by giving a keyword argument 'msg'"""

    commit_msg=kwargs.get('msg', "mkdir by py lib invocation")

    createpath = self.join(*args)

    createpath._svnwrite('mkdir', '-m', commit_msg)

    self._norev_delentry(createpath.dirpath())

    return createpath

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

                                            |--| ext

        """

    obj = object.__new__(self.__class__)

    obj.rev = kw.get('rev', self.rev)

    obj.auth = kw.get('auth', self.auth)

    dirname, basename, purebasename, ext = self._getbyspec(

         "dirname,basename,purebasename,ext")

    if 'basename' in kw:

        if 'purebasename' in kw or 'ext' in kw:

            raise ValueError("invalid specification %r" % kw)

    else:

        pb = kw.setdefault('purebasename', purebasename)

        ext = kw.setdefault('ext', ext)

        if ext and not ext.startswith('.'):

            ext = '.' + ext

        kw['basename'] = pb + ext

    kw.setdefault('dirname', dirname)

    kw.setdefault('sep', self.sep)

    if kw['basename']:

        obj.strpath = "%(dirname)s%(sep)s%(basename)s" % kw

    else:

        obj.strpath = "%(dirname)s" % kw

    return obj

def open(self, mode='r'):

    """ return an opened file with the given mode. """

    assert 'w' not in mode and 'a' not in mode, "XXX not implemented for svn cmdline"

    assert self.check(file=1) # svn cat returns an empty file otherwise

    if self.rev is None:

        return self._svnpopenauth('svn cat "%s"' % (

                                  self._escape(self.strpath), ))

    else:

        return self._svnpopenauth('svn cat -r %s "%s"' % (

                                  self.rev, self._escape(self.strpath)))

def parts(self, reverse=False):

    """ return a root-first list of all ancestor directories

            plus the path itself.

        """

    current = self

    l = [self]

    while 1:

        last = current

        current = current.dirpath()

        if last == current:

            break

        l.insert(0, current)

    if reverse:

        l.reverse()

    return l

def propget(self, name):

    """ return the content of the given property. """

    value = self._propget(name)

    return value

def proplist(self):

    """ list all property names. """

    content = self._proplist()

    return content

def read(self, mode='rb'):

    """ read and return a bytestring from reading the path. """

    if py.std.sys.version_info < (2,3):

        for x in 'u', 'U':

            if x in mode:

                mode = mode.replace(x, '')

    f = self.open(mode)

    try:

        return f.read()

    finally:

        f.close()