from kallithea.lib.vcs.exceptions import RepositoryError

from kallithea.lib.vcs.utils import ascii_bytes, ascii_str, safe_bytes, safe_str  # re-export

from kallithea.lib.vcs.utils.lazy import LazyProperty

try:

    import pwd

except ImportError:

    pass

log = logging.getLogger(__name__)

# mute pyflakes "imported but unused"

assert asbool

assert aslist

assert ascii_bytes

assert ascii_str

assert safe_bytes

assert safe_str

assert LazyProperty

def convert_line_endings(line, mode):

    """

    Converts a given line  "line end" according to given mode

    Available modes are::

        0 - Unix

        1 - Mac

        2 - DOS

    :param line: given line to convert

    :param mode: mode to convert to

    :rtype: str

    :return: converted line according to mode

    """

    if mode == 0:

        line = line.replace('\r\n', '\n')

        line = line.replace('\r', '\n')

    elif mode == 1:

        line = line.replace('\r\n', '\r')

        line = line.replace('\n', '\r')

    elif mode == 2:

        line = re.sub("\r(?!\n)|(?<!\r)\n", "\r\n", line)

    return line

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Apr 9, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

import os

import posixpath

import re

import sys

import tempfile

import traceback

import pkg_resources

from tg.i18n import ugettext as _

import kallithea

from kallithea.lib.auth import HasPermissionAny, HasRepoGroupPermissionLevel, HasRepoPermissionLevel, HasUserGroupPermissionLevel

from kallithea.lib.exceptions import IMCCommitError, NonRelativePathError

from kallithea.lib.hooks import process_pushed_raw_ids

from kallithea.lib.utils import action_logger, get_filesystem_repos, make_ui

from kallithea.lib.vcs import get_repo

from kallithea.lib.vcs.backends.base import EmptyChangeset

from kallithea.lib.vcs.exceptions import RepositoryError, VCSError

from kallithea.lib.vcs.nodes import FileNode

from kallithea.lib.vcs.utils.lazy import LazyProperty

from kallithea.model import db, meta

log = logging.getLogger(__name__)

class UserTemp(object):

    def __init__(self, user_id):

        self.user_id = user_id

    def __repr__(self):

        return "<%s('id:%s')>" % (self.__class__.__name__, self.user_id)

class RepoTemp(object):

    def __init__(self, repo_id):

        self.repo_id = repo_id

    def __repr__(self):

                log.debug("Found symlink hook at %s", hook_file)

                other_hook = True

            elif os.path.isfile(hook_file):

                log.debug('hook exists, checking if it is from kallithea')

                with open(hook_file, 'rb') as f:

                    data = f.read()

                    matches = re.search(br'^KALLITHEA_HOOK_VER\s*=\s*(.*)$', data, flags=re.MULTILINE)

                    if matches:

                        ver = safe_str(matches.group(1))

                        log.debug('Found Kallithea hook - it has KALLITHEA_HOOK_VER %s', ver)

                    else:

                        log.debug('Found non-Kallithea hook at %s', hook_file)

                        other_hook = True

            elif os.path.exists(hook_file):

                log.debug("Found hook that isn't a regular file at %s", hook_file)

                other_hook = True

            if other_hook and not force:

                log.warning('skipping overwriting hook file %s', hook_file)

            else:

                log.debug('writing %s hook file !', h_type)

                try:

                    fh, fn = tempfile.mkstemp(prefix=hook_file + '.tmp.')

                    os.write(fh, tmpl.replace(b'_TMPL_', safe_bytes(kallithea.__version__)))

                    os.close(fh)

                    os.rename(fn, hook_file)

                except (OSError, IOError) as e:

                    log.error('error writing hook %s: %s', hook_file, e)

def AvailableRepoGroupChoices(repo_group_perm_level, extras=()):

    """Return group_id,string tuples with choices for all the repo groups where

    the user has the necessary permissions.

    Top level is -1.

    """

    groups = db.RepoGroup.query().all()

    if HasPermissionAny('hg.admin')('available repo groups'):

        groups.append(None)

    else:

        groups = list(RepoGroupList(groups, perm_level=repo_group_perm_level))

        if HasPermissionAny('hg.create.repository')('available repo groups'):

            groups.append(None)

        for extra in extras:

            if not any(rg == extra for rg in groups):

                groups.append(extra)

    return db.RepoGroup.groups_choices(groups=groups)