def update(self, revision=None, needs_revert=True):
        """Does a clean update of the given path

        :param revision: ignored for hg
        """
        output_revert = ""
        if needs_revert:
            # revert local changes (avoids conflicts)
            command = ["hg", "-R", self.root_dir, "revert",
                    "--all", self.location_abs]
            exitcode, output_revert, error = run_command(command)
            if exitcode != 0:
                raise IOError("[Mercurial] error running '%s': %s" %
                              (command, error))

        # pull new patches
        command = ["hg", "-R", self.root_dir, "pull"]
        exitcode, output_pull, error = run_command(command)
        if exitcode != 0:
            raise IOError("[Mercurial] error running '%s': %s" %
                          (command, error))
        # update working directory
        command = ["hg", "-R", self.root_dir, "update"]
        exitcode, output_update, error = run_command(command)
        if exitcode != 0:
            raise IOError("[Mercurial] error running '%s': %s" %
                          (command, error))
        return output_revert + output_pull + output_update

 def commit(self, message=None, author=None, add=True):
     """Commits the file and supplies the given commit message if present"""
     # add the file
     output_add = ""
     if add:
         command = self._get_git_command(["add", self.location_rel])
         exitcode, output_add, error = run_command(command, self.root_dir)
         if exitcode != 0:
             raise IOError("[GIT] add of ('%s', '%s') failed: %s" \
                     % (self.root_dir, self.location_rel, error))
     # commit file
     command = self._get_git_command(["commit"])
     if message:
         command.extend(["-m", message])
     if author:
         command.extend(["--author", author])
     exitcode, output_commit, error = run_command(command, self.root_dir)
     if exitcode != 0:
         if len(error):
             msg = error
         else:
             msg = output_commit
         raise IOError("[GIT] commit of ('%s', '%s') failed: %s" \
                 % (self.root_dir, self.location_rel, msg))
     # push changes
     command = self._get_git_command(["push"])
     exitcode, output_push, error = run_command(command, self.root_dir)
     if exitcode != 0:
         raise IOError("[GIT] push of ('%s', '%s') failed: %s" \
                 % (self.root_dir, self.location_rel, error))
     return output_add + output_commit + output_push

 def update(self, revision=None):
     """Does a clean update of the given path"""
     # git checkout
     command = self._get_git_command(["checkout", self.location_rel])
     exitcode, output_checkout, error = run_command(command, self.root_dir)
     if exitcode != 0:
         raise IOError("[GIT] checkout failed (%s): %s" % (command, error))
     # pull changes
     command = self._get_git_command(["pull"])
     exitcode, output_pull, error = run_command(command, self.root_dir)
     if exitcode != 0:
         raise IOError("[GIT] pull failed (%s): %s" % (command, error))
     return output_checkout + output_pull

 def update(self, revision=None):
     """Does a clean update of the given path"""
     # bzr revert
     command = ["bzr", "revert", self.location_abs]
     exitcode, output_revert, error = run_command(command)
     if exitcode != 0:
         raise IOError("[BZR] revert of '%s' failed: %s" \
                 % (self.location_abs, error))
     # bzr pull
     command = ["bzr", "pull"]
     exitcode, output_pull, error = run_command(command)
     if exitcode != 0:
         raise IOError("[BZR] pull of '%s' failed: %s" \
                 % (self.location_abs, error))
     return output_revert + output_pull

 def update(self, revision=None, needs_revert=True):
     """Does a clean update of the given path"""
     #TODO: take needs_revert parameter into account
     working_dir = os.path.dirname(self.location_abs)
     filename = self.location_abs
     filename_backup = filename + os.path.extsep + "bak"
     # rename the file to be updated
     try:
         os.rename(filename, filename_backup)
     except OSError as error:
         raise IOError("[CVS] could not move the file '%s' to '%s': %s" % (
                       filename, filename_backup, error))
     command = ["cvs", "-Q", "update", "-C"]
     if revision:
         command.extend(["-r", revision])
     # the filename is the last argument
     command.append(os.path.basename(filename))
     # run the command within the given working_dir
     exitcode, output, error = run_command(command, working_dir)
     # restore backup in case of an error - remove backup for success
     try:
         if exitcode != 0:
             os.rename(filename_backup, filename)
         else:
             os.remove(filename_backup)
     except OSError:
         pass
     # raise an error or return successfully - depending on the CVS command
     if exitcode != 0:
         raise IOError("[CVS] Error running CVS command '%s': %s" %
                       (command, error))
     else:
         return output

    def update(self, revision=None):
        """Does a clean update of the given path

        :param revision: ignored for darcs
        """
        # revert local changes (avoids conflicts)
        command = ["darcs", "revert", "--repodir", self.root_dir,
                "-a", self.location_rel]
        exitcode, output_revert, error = run_command(command)
        if exitcode != 0:
            raise IOError("[Darcs] error running '%s': %s" % (command, error))
        # pull new patches
        command = ["darcs", "pull", "--repodir", self.root_dir, "-a"]
        exitcode, output_pull, error = run_command(command)
        if exitcode != 0:
            raise IOError("[Darcs] error running '%s': %s" % (command, error))
        return output_revert + output_pull

 def getcleanfile(self, revision=None):
     """Get a clean version of a file from the git repository"""
     # run git-show
     command = self._get_git_command(["show", "HEAD:%s" % self.location_rel])
     exitcode, output, error = run_command(command, self.root_dir)
     if exitcode != 0:
         raise IOError("[GIT] 'show' failed for ('%s', %s): %s" \
                 % (self.root_dir, self.location_rel, error))
     return output

 def getcleanfile(self, revision=None):
     """Get a clean version of a file from the bzr repository"""
     # bzr cat
     command = ["bzr", "cat", self.location_abs]
     exitcode, output, error = run_command(command)
     if exitcode != 0:
         raise IOError("[BZR] cat failed for '%s': %s" % (
                       self.location_abs, error))
     return output

def get_version():
    """return a tuple of (major, minor) for the installed subversion client"""
    command = ["svn", "--version", "--quiet"]
    exitcode, output, error = run_command(command)
    if exitcode == 0:
        major, minor = output.strip().split(".")[0:2]
        if (major.isdigit() and minor.isdigit()):
            return (int(major), int(minor))
    # something went wrong above
    return (0, 0)

def get_version():
    """return a tuple of (major, minor) for the installed subversion client"""
    exitcode, output, error = run_command(["p4", "-V"])
    
    if exitcode == 0:
        major, minor = output.strip().split("/")[2].split(".")[:2]
        if (major.isdigit() and minor.isdigit()):
            return (int(major), int(minor))
    # something went wrong above
    return (0, 0)

 def getcleanfile(self, revision=None):
     """Get a clean version of a file from the hg repository"""
     # run hg cat
     command = ["hg", "-R", self.root_dir, "cat",
             self.location_abs]
     exitcode, output, error = run_command(command)
     if exitcode != 0:
         raise IOError("[Mercurial] Error running '%s': %s" \
                 % (command, error))
     return output

    def add(self, files, message=None, author=None):
        """Add and commit the new files."""
        args = ["add"] + prepare_filelist(files)
        command = self._get_git_command(args)
        exitcode, output, error = run_command(command, self.root_dir)
        if exitcode != 0:
            raise IOError("[GIT] add of files in '%s') failed: %s" \
                    % (self.root_dir, error))

        return output + self.commit(message, author, add=False)

    def add(self, files, message=None, author=None):
        """Add and commit the new files."""
        command = ["hg", "add", "-q", "--parents"] + prepare_filelist(files)
        exitcode, output, error = run_command(command)
        if exitcode != 0:
            raise IOError("[Mercurial] Error running '%s': %s" % (command, error))

        # go down as deep as possible in the tree to avoid accidental commits
        # TODO: explicitly commit files by name
        youngest_ancestor = os.path.commonprefix(files)
        return output + type(self)(youngest_ancestor).commit(message, author)

 def update(self, revision=None):
     """update the working copy - remove local modifications if necessary"""
     # revert the local copy (remove local changes)
     command = ["svn", "revert", self.location_abs]
     exitcode, output_revert, error = run_command(command)
     # any errors?
     if exitcode != 0:
         raise IOError("[SVN] Subversion error running '%s': %s" \
                 % (command, error))
     # update the working copy to the given revision
     command = ["svn", "update"]
     if not revision is None:
         command.extend(["-r", revision])
     # the filename is the last argument
     command.append(self.location_abs)
     exitcode, output_update, error = run_command(command)
     if exitcode != 0:
         raise IOError("[SVN] Subversion error running '%s': %s" \
                 % (command, error))
     return output_revert + output_update

 def getcleanfile(self, revision=None):
     """return the content of the 'head' revision of the file"""
     command = ["svn", "cat"]
     if not revision is None:
         command.extend(["-r", revision])
     # the filename is the last argument
     command.append(self.location_abs)
     exitcode, output, error = run_command(command)
     if exitcode != 0:
         raise IOError("[SVN] Subversion error running '%s': %s" % (command, error))
     return output

 def update(self, revision=None):
     """update the working copy - remove local modifications if necessary"""
     # revert the local copy (remove local changes)
     command = ["p4", "revert", self.location_abs]
     exitcode, output_revert, error = run_command(command)
     # any errors?
     if exitcode != 0:
         raise IOError("[P4] Perforce error running '%s': %s" \
                 % (command, error))
     # update the working copy to the given revision
     command = ["p4", "sync"]
     if not revision is None:
         command.append(self.location_abs + "@" + revision)
     if not revision is None:
         command.append(self.location_abs)
     exitcode, output_update, error = run_command(command)
     if exitcode != 0:
         raise IOError("[P4] Perforce error running '%s': %s" \
                 % (command, error))
     return output_revert + output_update

    def add(self, files, message=None, author=None):
        """Add and commit files."""
        command = ["bzr", "add"] + prepare_filelist(files)
        exitcode, output, error = run_command(command)
        if exitcode != 0:
            raise IOError("[BZR] add in '%s' failed: %s" \
                    % (self.location_abs, error))

        # go down as deep as possible in the tree to avoid accidental commits
        # TODO: explicitly commit files by name
        youngest_ancestor = os.path.commonprefix(files)
        return output + type(self)(youngest_ancestor).commit(message, author)

    def add(self, files, message=None, author=None):
        """Add and commit files."""
        command = ["darcs", "add", "--repodir", self.root_dir] + prepare_filelist(files)
        exitcode, output, error = run_command(command)
        if exitcode != 0:
            raise IOError("[Darcs] Error running darcs command '%s': %s" \
                    % (command, error))

        # go down as deep as possible in the tree to avoid accidental commits
        # TODO: explicitly commit files by name
        youngest_ancestor = os.path.commonprefix(files)
        return output + type(self)(youngest_ancestor).commit(message, author)

 def commit(self, message=None, author=None):
     """Commits the file and supplies the given commit message if present"""
     if message is None:
         message = ""
     # commit changes
     command = ["hg", "-R", self.root_dir, "commit", "-m", message]
     # add the 'author' argument, if it was given (only supported since v1.0)
     if author and (get_version() >= (1, 0)):
         command.extend(["--user", author])
     # the location is the last argument
     command.append(self.location_abs)
     exitcode, output_commit, error = run_command(command)
     if exitcode != 0:
         raise IOError("[Mercurial] Error running '%s': %s" \
                 % (command, error))
     # push changes
     command = ["hg", "-R", self.root_dir, "push"]
     exitcode, output_push, error = run_command(command)
     if exitcode != 0:
         raise IOError("[Mercurial] Error running '%s': %s" \
                 % (command, error))
     return output_commit + output_push

    def add(self, files, message=None, author=None):
        """Add and commit the new files."""
        files = prepare_filelist(files)
        command = ["svn", "add", "-q", "--non-interactive", "--parents"] + files
        exitcode, output, error = run_command(command)
        if exitcode != 0:
            raise IOError("[SVN] Error running SVN command '%s': %s" %
                          (command, error))

        # go down as deep as possible in the tree to avoid accidental commits
        # TODO: explicitly commit files by name
        ancestor = youngest_ancestor(files)
        return output + type(self)(ancestor).commit(message, author)