[run]

omit =

    # the bin scripts are not part of the Kallithea web app

    kallithea/bin/*

    # we ship with no active extensions

    kallithea/config/rcextensions/*

    # dbmigrate is not a part of the Kallithea web app

    kallithea/lib/dbmigrate/*

    # the tests themselves should not be part of the coverage report

    kallithea/tests/*

# same omit lines should be present in sections 'run' and 'report'

[report]

omit =

    # the bin scripts are not part of the Kallithea web app

    kallithea/bin/*

    # we ship with no active extensions

    kallithea/config/rcextensions/*

    # dbmigrate is not a part of the Kallithea web app

    kallithea/lib/dbmigrate/*

    # the tests themselves should not be part of the coverage report

    kallithea/tests/*

[paths]

source =

    kallithea/

    **/workspace/*/kallithea

# -*- coding: utf-8 -*-

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""

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

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

:created_on: Mar 6, 2012

:author: marcink

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

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

"""

import os

import click

import pkg_resources

import kallithea

import kallithea.bin.kallithea_cli_base as cli_base

from kallithea.lib.utils2 import ask_ok

@cli_base.register_command(needs_config_file=True)

def extensions_create():

    """Write template file for extending Kallithea in Python.

    Create a template `extensions.py` file next to the ini file. Local

    customizations in that file will survive upgrades. The file contains

    instructions on how it can be customized.

    """

    here = kallithea.CONFIG['here']

    content = pkg_resources.resource_string(

    )

    ext_file = os.path.join(here, 'extensions.py')

    if os.path.exists(ext_file):

        msg = ('Extension file %s already exists, do you want '

               'to overwrite it ? [y/n] ') % ext_file

        if not ask_ok(msg):

            click.echo('Nothing done, exiting...')

            return

    dirname = os.path.dirname(ext_file)

    if not os.path.isdir(dirname):

        os.makedirs(dirname)

    with open(ext_file, 'wb') as f:

        f.write(content)

        click.echo('Wrote new extensions file to %s' % ext_file)

        branches_group = ([('branch:%s' % k, k) for k, v in

                           repo.branches.items()], _("Branches"))

        hist_l.append(branches_group)

        choices.extend([x[0] for x in branches_group[0]])

        if repo.alias == 'hg':

            bookmarks_group = ([('book:%s' % k, k) for k, v in

                                repo.bookmarks.items()], _("Bookmarks"))

            hist_l.append(bookmarks_group)

            choices.extend([x[0] for x in bookmarks_group[0]])

        tags_group = ([('tag:%s' % k, k) for k, v in

                       repo.tags.items()], _("Tags"))

        hist_l.append(tags_group)

        choices.extend([x[0] for x in tags_group[0]])

        return choices, hist_l

    def _get_git_hook_interpreter(self):

        """Return a suitable interpreter for Git hooks.

        Return a suitable string to be written in the POSIX #! shebang line for

        Git hook scripts so they invoke Kallithea code with the right Python

        interpreter and in the right environment.

        """

        # Note: sys.executable might not point at a usable Python interpreter. For

        # example, when using uwsgi, it will point at the uwsgi program itself.

        # FIXME This may not work on Windows and may need a shell wrapper script.

        return (kallithea.CONFIG.get('git_hook_interpreter')

                or sys.executable

                or '/usr/bin/env python3')

    def install_git_hooks(self, repo, force=False):

        """

        Creates a kallithea hook inside a git repository

        :param repo: Instance of VCS repo

        :param force: Overwrite existing non-Kallithea hooks

        """

        hooks_path = os.path.join(repo.path, 'hooks')

        if not repo.bare:

            hooks_path = os.path.join(repo.path, '.git', 'hooks')

        if not os.path.isdir(hooks_path):

            os.makedirs(hooks_path)

        tmpl_post = b"#!%s\n" % safe_bytes(self._get_git_hook_interpreter())

        tmpl_post += pkg_resources.resource_string(

        )

        tmpl_pre = b"#!%s\n" % safe_bytes(self._get_git_hook_interpreter())

        tmpl_pre += pkg_resources.resource_string(

        )

        for h_type, tmpl in [('pre', tmpl_pre), ('post', tmpl_post)]:

            hook_file = os.path.join(hooks_path, '%s-receive' % h_type)

            other_hook = False

            log.debug('Installing git hook in repo %s', repo)

            if os.path.exists(hook_file):

                # let's take a look at this hook, maybe it's kallithea ?

                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 = matches.groups()[0]

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

                    else:

                        log.debug('Found non-Kallithea hook 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:

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

                        tmpl = tmpl.replace(b'_TMPL_', safe_bytes(kallithea.__version__))

                        f.write(tmpl)

                    os.chmod(hook_file, 0o755)

                except 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 = 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)