[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

: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)

        """

        # 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: