it will return given explicit alias in repositories under more than one

      version control, if explicit_alias is different than found it will raise

      VCSError

    """

    if not os.path.isdir(path):

        raise VCSError("Given path %s is not a directory" % path)

    def get_scms(path):

        return [(scm, path) for scm in get_scms_for_path(path)]

    found_scms = get_scms(path)

    while not found_scms and search_up:

        newpath = abspath(path, '..')

        if newpath == path:

            break

        path = newpath

        found_scms = get_scms(path)

    if len(found_scms) > 1:

        for scm in found_scms:

            if scm[0] == explicit_alias:

                return scm

        raise VCSError('More than one [%s] scm found at given path %s'

                       % (', '.join((x[0] for x in found_scms)), path))

    if len(found_scms) is 0:

        raise VCSError('No scm found at given path %s' % path)

    return found_scms[0]

def get_scms_for_path(path):

    """

    Returns all scm's found at the given path. If no scm is recognized

    - empty list is returned.

    :param path: path to directory which should be checked. May be callable.

    :raises VCSError: if given ``path`` is not a directory

    """

    from kallithea.lib.vcs.backends import get_backend

    if hasattr(path, '__call__'):

        path = path()

    if not os.path.isdir(path):

        raise VCSError("Given path %r is not a directory" % path)

    result = []

    for key in ALIASES:

        dirname = os.path.join(path, '.' + key)

        if os.path.isdir(dirname):

            result.append(key)

            continue

        dirname = os.path.join(path, 'rm__.' + key)

        if os.path.isdir(dirname):

            return result

        # We still need to check if it's not bare repository as

        # bare repos don't have working directories

        try:

            get_backend(key)(path)

            result.append(key)

            continue

        except RepositoryError:

            # Wrong backend

            pass

        except VCSError:

            # No backend at all

            pass

    return result

def run_command(cmd, *args):

    """

    Runs command on the system with given ``args``.

    """

    command = ' '.join((cmd, args))

    p = Popen(command, shell=True, stdout=PIPE, stderr=PIPE)

    stdout, stderr = p.communicate()

    return p.retcode, stdout, stderr

def get_highlighted_code(name, code, type='terminal'):

    """

    If pygments are available on the system

    then returned output is colored. Otherwise

    unchanged content is returned.

    """

    import logging

    try:

        import pygments

        pygments

    except ImportError:

        return code

    from pygments import highlight

    from pygments.lexers import guess_lexer_for_filename, ClassNotFound

    from pygments.formatters import TerminalFormatter

    try:

        lexer = guess_lexer_for_filename(name, code)

        formatter = TerminalFormatter()

        content = highlight(code, lexer, formatter)

        # check if this path is a group

        if is_valid_repo_group(repo_path, self.repos_path):

            raise Exception('This path %s is a valid group' % repo_path)

        log.info('creating repo %s in %s from url: `%s`' % (

            repo_name, safe_unicode(repo_path),

            obfuscate_url_pw(clone_uri)))

        backend = get_backend(repo_type)

        if repo_type == 'hg':

            baseui = make_ui('db', clear_session=False)

            # patch and reset hooks section of UI config to not run any

            # hooks on creating remote repo

            for k, v in baseui.configitems('hooks'):

                baseui.setconfig('hooks', k, None)

            repo = backend(repo_path, create=True, src_url=clone_uri, baseui=baseui)

        elif repo_type == 'git':

            repo = backend(repo_path, create=True, src_url=clone_uri, bare=True)

            # add kallithea hook into this repo

            ScmModel().install_git_hook(repo=repo)

        else:

            raise Exception('Not supported repo_type %s expected hg/git' % repo_type)

        log.debug('Created repo %s with %s backend'

                  % (safe_unicode(repo_name), safe_unicode(repo_type)))

        return repo

    def _rename_filesystem_repo(self, old, new):

        """

        renames repository on filesystem

        :param old: old name

        :param new: new name

        """

        log.info('renaming repo from %s to %s' % (old, new))

        old_path = os.path.join(self.repos_path, old)

        new_path = os.path.join(self.repos_path, new)

        if os.path.isdir(new_path):

            raise Exception(

                'Was trying to rename to already existing dir %s' % new_path

            )

        shutil.move(old_path, new_path)

    def _delete_filesystem_repo(self, repo):

        """

        :param repo: repo object

        """

        rm_path = os.path.join(self.repos_path, repo.repo_name)

        _now = datetime.now()

        _ms = str(_now.microsecond).rjust(6, '0')

        _d = 'rm__%s__%s' % (_now.strftime('%Y%m%d_%H%M%S_' + _ms),

                             repo.just_name)

        if repo.group:

            args = repo.group.full_path_splitted + [_d]

            _d = os.path.join(*args)