# -*- 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/>.

"""

Helper functions

Consists of functions to typically be used within templates, but also

available to Controllers. This module is available to both as 'h'.

"""

import hashlib

import logging

import re

import textwrap

import urllib.parse

from beaker.cache import cache_region

from pygments import highlight as code_highlight

from pygments.formatters.html import HtmlFormatter

from tg import tmpl_context as c

from tg.i18n import ugettext as _

import kallithea

from kallithea.lib.annotate import annotate_highlight

#==============================================================================

# PERMS

#==============================================================================

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

from kallithea.lib.diffs import BIN_FILENODE, CHMOD_FILENODE, DEL_FILENODE, MOD_FILENODE, NEW_FILENODE, RENAMED_FILENODE

from kallithea.lib.markup_renderer import url_re

from kallithea.lib.pygmentsutils import get_custom_lexer

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

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError

#==============================================================================

# SCM FILTERS available via h.

#==============================================================================

from kallithea.lib.vcs.utils import author_email, author_name

from kallithea.model import db

from kallithea.model.changeset_status import ChangesetStatusModel

# mute pyflakes "imported but unused"

# from webutils

assert HTML

assert Option

assert canonical_url

assert checkbox

assert chop_at

assert end_form

assert form

assert format_byte_size

assert hidden

assert js

assert jshtml

assert password

assert pop_flash_messages

assert radio

assert reset

assert safeid

assert select

assert session_csrf_secret_name

assert session_csrf_secret_token

assert submit

assert text

assert textarea

assert wrap_paragraphs

# from kallithea.lib.auth

assert HasPermissionAny

assert HasRepoGroupPermissionLevel

assert HasRepoPermissionLevel

# from utils2

assert age

assert fmt_date

assert link_to_ref

assert shorter

assert time_to_datetime

# from vcs

assert EmptyChangeset

log = logging.getLogger(__name__)

def FID(raw_id, path):

    """

    Creates a unique ID for filenode based on it's hash of path and revision

    it's safe to use in urls

    """

    return 'C-%s-%s' % (short_id(raw_id), hashlib.md5(safe_bytes(path)).hexdigest()[:12])

def get_ignore_whitespace_diff(GET):

    """Return true if URL requested whitespace to be ignored"""

    return bool(GET.get('ignorews'))

def ignore_whitespace_link(GET, anchor=None):

    """Return snippet with link to current URL with whitespace ignoring toggled"""

    params = dict(GET)  # ignoring duplicates

    if get_ignore_whitespace_diff(GET):

        params.pop('ignorews')

        title = _("Show whitespace changes")

    else:

        params['ignorews'] = '1'

        title = _("Ignore whitespace changes")

    params['anchor'] = anchor

    return link_to(

        literal('<i class="icon-strike"></i>'),

        url.current(**params),

        title=title,

        **{'data-toggle': 'tooltip'})

def get_diff_context_size(GET):

    """Return effective context size requested in URL"""

    return safe_int(GET.get('context'), default=3)

def increase_context_link(GET, anchor=None):

    """Return snippet with link to current URL with double context size"""

    context = get_diff_context_size(GET) * 2

    params = dict(GET)  # ignoring duplicates

    params['context'] = str(context)

    params['anchor'] = anchor

    return link_to(

        literal('<i class="icon-sort"></i>'),

        url.current(**params),

        title=_('Increase diff context to %(num)s lines') % {'num': context},

        **{'data-toggle': 'tooltip'})

def files_breadcrumbs(repo_name, rev, paths):

    url_l = [link_to(repo_name, url('files_home',

                                    repo_name=repo_name,

                                    revision=rev, f_path=''),

                     class_='ypjax-link')]

    paths_l = paths.split('/')

    for cnt, p in enumerate(paths_l):

        if p != '':

            url_l.append(link_to(p,

                                 url('files_home',

                                     repo_name=repo_name,

                                     revision=rev,

                                     f_path='/'.join(paths_l[:cnt + 1])

                                     ),

                                 class_='ypjax-link'

                                 )

                         )

    return literal('/'.join(url_l))

class CodeHtmlFormatter(HtmlFormatter):

    """

    My code Html Formatter for source codes

    """

    def wrap(self, source, outfile):

        return self._wrap_div(self._wrap_pre(self._wrap_code(source)))

    def _wrap_code(self, source):

        for cnt, it in enumerate(source):

            i, t = it

            t = '<span id="L%s">%s</span>' % (cnt + 1, t)

            yield i, t

    def _wrap_tablelinenos(self, inner):

        inner_lines = []

        lncount = 0

        for t, line in inner:

            if t:

                lncount += 1

            inner_lines.append(line)

        fl = self.linenostart

        mw = len(str(lncount + fl - 1))

        sp = self.linenospecial

        st = self.linenostep

        la = self.lineanchors

        aln = self.anchorlinenos

        nocls = self.noclasses

        if sp:

            lines = []

            for i in range(fl, fl + lncount):

                if i % st == 0:

                    if i % sp == 0:

                        if aln:

                            lines.append('<a href="#%s%d" class="special">%*d</a>' %

                                         (la, i, mw, i))

                        else:

                            lines.append('<span class="special">%*d</span>' % (mw, i))

                    else:

                        if aln:

                            lines.append('<a href="#%s%d">%*d</a>' % (la, i, mw, i))

                        else:

                            lines.append('%*d' % (mw, i))

                else:

                    lines.append('')

            ls = '\n'.join(lines)

        else:

            lines = []

            for i in range(fl, fl + lncount):

                if i % st == 0:

                    if aln:

                        lines.append('<a href="#%s%d">%*d</a>' % (la, i, mw, i))

                    else:

                        lines.append('%*d' % (mw, i))

                else:

                    lines.append('')

            ls = '\n'.join(lines)

        # in case you wonder about the seemingly redundant <div> here: since the

        # content in the other cell also is wrapped in a div, some browsers in

        # some configurations seem to mess up the formatting...

        if nocls:

            yield 0, ('<table class="%stable">' % self.cssclass +

                      '<tr><td><div class="linenodiv">'

                      '<pre>' + ls + '</pre></div></td>'

                      '<td id="hlcode" class="code">')

        else:

            yield 0, ('<table class="%stable">' % self.cssclass +

                      '<tr><td class="linenos"><div class="linenodiv">'

                      '<pre>' + ls + '</pre></div></td>'

                      '<td id="hlcode" class="code">')

        yield 0, ''.join(inner_lines)

        yield 0, '</td></tr></table>'

_whitespace_re = re.compile(r'(\t)|( )(?=\n|</div>)')

# -*- 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/>.

"""

kallithea.lib.markup_renderer

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Renderer for markup languages with ability to parse using rst or markdown

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: Oct 27, 2011

:author: marcink

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

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

"""

import hashlib

import logging

import re

import traceback

import bleach

import markdown as markdown_mod

from docutils.core import publish_parts

from docutils.parsers.rst import directives

log = logging.getLogger(__name__)

url_re = re.compile(r'''\bhttps?://(?:[\da-zA-Z0-9@:.-]+)'''

                    r'''(?:[/a-zA-Z0-9_=@#~&+%.,:;?!*()-]*[/a-zA-Z0-9_=@#~])?''')

class MarkupRenderer(object):

    RESTRUCTUREDTEXT_DISALLOWED_DIRECTIVES = ['include', 'meta', 'raw']

    MARKDOWN_PAT = re.compile(r'md|mkdn?|mdown|markdown', re.IGNORECASE)

    RST_PAT = re.compile(r're?st', re.IGNORECASE)

    PLAIN_PAT = re.compile(r'readme', re.IGNORECASE)

    @classmethod

    def _detect_renderer(cls, source, filename):

        """

        runs detection of what renderer should be used for generating html

        from a markup language

        filename can be also explicitly a renderer name

        """

        if cls.MARKDOWN_PAT.findall(filename):

            return cls.markdown

        elif cls.RST_PAT.findall(filename):

            return cls.rst

        elif cls.PLAIN_PAT.findall(filename):

            return cls.rst

        return cls.plain

    @classmethod

    def _flavored_markdown(cls, text):

        """

        Github style flavored markdown

        :param text:

        """

        # Extract pre blocks.

        extractions = {}

        def pre_extraction_callback(matchobj):

            digest = hashlib.sha1(matchobj.group(0)).hexdigest()

            extractions[digest] = matchobj.group(0)

            return "{gfm-extraction-%s}" % digest

        pattern = re.compile(r'<pre>.*?</pre>', re.MULTILINE | re.DOTALL)

        text = re.sub(pattern, pre_extraction_callback, text)

        # Prevent foo_bar_baz from ending up with an italic word in the middle.

        def italic_callback(matchobj):

            s = matchobj.group(0)

            if list(s).count('_') >= 2:

                return s.replace('_', r'\_')

            return s

        text = re.sub(r'^(?! {4}|\t)\w+_\w+_\w[\w_]*', italic_callback, text)

        # In very clear cases, let newlines become <br /> tags.

        def newline_callback(matchobj):

            if len(matchobj.group(1)) == 1:

                return matchobj.group(0).rstrip() + '  \n'

            else:

                return matchobj.group(0)

        pattern = re.compile(r'^[\w\<][^\n]*(\n+)', re.MULTILINE)

        text = re.sub(pattern, newline_callback, text)

        # Insert pre block extractions.

        def pre_insert_callback(matchobj):

            return '\n\n' + extractions[matchobj.group(1)]

        text = re.sub(r'{gfm-extraction-([0-9a-f]{32})\}',

                      pre_insert_callback, text)

        return text

    @classmethod

    def render(cls, source, filename=None):

        """

        Renders a given filename using detected renderer

        it detects renderers based on file extension or mimetype.

        At last it will just do a simple html replacing new lines with <br/>

        >>> MarkupRenderer.render('''<img id="a" style="margin-top:-1000px;color:red" src="http://example.com/test.jpg">''', '.md')

        '<p><img id="a" src="http://example.com/test.jpg" style="color: red;"></p>'

        >>> MarkupRenderer.render('''<img class="c d" src="file://localhost/test.jpg">''', 'b.mkd')

        '<p><img class="c d"></p>'

        >>> MarkupRenderer.render('''<a href="foo">foo</a>''', 'c.mkdn')

        '<p><a href="foo">foo</a></p>'

        >>> MarkupRenderer.render('''<script>alert(1)</script>''', 'd.mdown')

        '<script>alert(1)</script>'

        >>> MarkupRenderer.render('''<div onclick="alert(2)">yo</div>''', 'markdown')

        '<div>yo</div>'

        >>> MarkupRenderer.render('''<a href="javascript:alert(3)">yo</a>''', 'md')

        '<p><a>yo</a></p>'

        """

        renderer = cls._detect_renderer(source, filename)

        readme_data = renderer(source)

        # Allow most HTML, while preventing XSS issues:

        # no <script> tags, no onclick attributes, no javascript

        # "protocol", and also limit styling to prevent defacing.

        return bleach.clean(readme_data,

            tags=['a', 'abbr', 'b', 'blockquote', 'br', 'code', 'dd',

                  'div', 'dl', 'dt', 'em', 'h1', 'h2', 'h3', 'h4', 'h5',

                  'h6', 'hr', 'i', 'img', 'li', 'ol', 'p', 'pre', 'span',

                  'strong', 'sub', 'sup', 'table', 'tbody', 'td', 'th',

                  'thead', 'tr', 'ul'],

            attributes=['class', 'id', 'style', 'label', 'title', 'alt', 'href', 'src'],

            styles=['color'],

            protocols=['http', 'https', 'mailto'],

            )

    @classmethod

    def plain(cls, source, universal_newline=True):

        """

        >>> MarkupRenderer.plain('https://example.com/')

        '<br /><a href="https://example.com/">https://example.com/</a>'

        """

        if universal_newline:

            newline = '\n'

            source = newline.join(source.splitlines())

        def url_func(match_obj):

            url_full = match_obj.group(0)

            return '<a href="%(url)s">%(url)s</a>' % ({'url': url_full})

        source = url_re.sub(url_func, source)

        return '<br />' + source.replace("\n", '<br />')

    @classmethod

    def markdown(cls, source, safe=True, flavored=False):

        """

        Convert Markdown (possibly GitHub Flavored) to INSECURE HTML, possibly

        with "safe" fall-back to plaintext. Output from this method should be sanitized before use.

        >>> MarkupRenderer.markdown('''<img id="a" style="margin-top:-1000px;color:red" src="http://example.com/test.jpg">''')

        '<p><img id="a" style="margin-top:-1000px;color:red" src="http://example.com/test.jpg"></p>'

        >>> MarkupRenderer.markdown('''<img class="c d" src="file://localhost/test.jpg">''')

        '<p><img class="c d" src="file://localhost/test.jpg"></p>'

        >>> MarkupRenderer.markdown('''<a href="foo">foo</a>''')

        '<p><a href="foo">foo</a></p>'

        >>> MarkupRenderer.markdown('''<script>alert(1)</script>''')

        '<script>alert(1)</script>'

        >>> MarkupRenderer.markdown('''<div onclick="alert(2)">yo</div>''')

        '<div onclick="alert(2)">yo</div>'

        >>> MarkupRenderer.markdown('''<a href="javascript:alert(3)">yo</a>''')

        '<p><a href="javascript:alert(3)">yo</a></p>'

        >>> MarkupRenderer.markdown('''## Foo''')

        '<h2>Foo</h2>'

        >>> print(MarkupRenderer.markdown('''

        ...     #!/bin/bash

        ...     echo "hello"

        ... '''))

        <table class="code-highlighttable"><tr><td class="linenos"><div class="linenodiv"><pre>1

        2</pre></div></td><td class="code"><div class="code-highlight"><pre><span></span><span class="ch">#!/bin/bash</span>

        <span class="nb">echo</span> <span class="s2">&quot;hello&quot;</span>

        </pre></div>

        </td></tr></table>

        """

        try:

            if flavored:

                source = cls._flavored_markdown(source)

            return markdown_mod.markdown(

                source,

                extensions=['markdown.extensions.codehilite', 'markdown.extensions.extra'],

                extension_configs={'markdown.extensions.codehilite': {'css_class': 'code-highlight'}})

        except Exception:

            log.error(traceback.format_exc())

            if safe:

                log.debug('Falling back to render in plain mode')

                return cls.plain(source)

            else:

                raise

    @classmethod

    def rst(cls, source, safe=True):

        try:

            docutils_settings = dict([(alias, None) for alias in

                                cls.RESTRUCTUREDTEXT_DISALLOWED_DIRECTIVES])

            docutils_settings.update({'input_encoding': 'unicode',

                                      'report_level': 4})

            for k, v in docutils_settings.items():

                directives.register_directive(k, v)

            parts = publish_parts(source=source,

                                  writer_name="html4css1",

                                  settings_overrides=docutils_settings)

            return parts['html_title'] + parts["fragment"]

        except Exception:

            log.error(traceback.format_exc())

            if safe:

                log.debug('Falling back to render in plain mode')

                return cls.plain(source)

            else:

                raise

    @classmethod

    def rst_with_mentions(cls, source):

        def wrapp(match_obj):

            uname = match_obj.groups()[0]

            return r'\ **@%(uname)s**\ ' % {'uname': uname}

        return cls.rst(mention_hl)

# -*- 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/>.

"""

kallithea.lib.utils

~~~~~~~~~~~~~~~~~~~

Utilities library for Kallithea

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 18, 2010

:author: marcink

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

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

"""

import logging

import os

import re

import traceback

import urllib.error

import mercurial.config

import mercurial.error

import mercurial.ui

import kallithea.lib.conf

from kallithea.lib.exceptions import InvalidCloneUriException

from kallithea.lib.vcs.backends.git.repository import GitRepository

from kallithea.lib.vcs.backends.hg.repository import MercurialRepository

from kallithea.lib.vcs.conf import settings

from kallithea.lib.vcs.exceptions import VCSError

from kallithea.lib.vcs.utils.fakemod import create_module

from kallithea.lib.vcs.utils.helpers import get_scm

from kallithea.model import db, meta

log = logging.getLogger(__name__)

REMOVED_REPO_PAT = re.compile(r'rm__\d{8}_\d{6}_\d{6}_.*')

#==============================================================================

# PERM DECORATOR HELPERS FOR EXTRACTING NAMES FOR PERM CHECKS

#==============================================================================

def get_repo_slug(request):

    _repo = request.environ['pylons.routes_dict'].get('repo_name')

    if _repo:

        _repo = _repo.rstrip('/')

    return _repo

def get_repo_group_slug(request):

    _group = request.environ['pylons.routes_dict'].get('group_name')

    if _group:

        _group = _group.rstrip('/')

    return _group

def get_user_group_slug(request):

    _group = request.environ['pylons.routes_dict'].get('id')

    _group = db.UserGroup.get(_group)

    if _group:

        return _group.users_group_name

    return None

def _get_permanent_id(s):

    """Helper for decoding stable URLs with repo ID. For a string like '_123'

    return 123.

    """

    by_id_match = re.match(r'^_(\d+)$', s)

    if by_id_match is None:

        return None

    return int(by_id_match.group(1))

def fix_repo_id_name(path):

    """

    Rewrite repo_name for _<ID> permanent URLs.

    Given a path, if the first path element is like _<ID>, return the path with

    this part expanded to the corresponding full repo name, else return the

    provided path.

    """

    first, rest = path, ''

    if '/' in path:

        first, rest_ = path.split('/', 1)

        rest = '/' + rest_

    repo_id = _get_permanent_id(first)

    if repo_id is not None:

        repo = db.Repository.get(repo_id)

        if repo is not None:

            return repo.repo_name + rest

    return path

def get_filesystem_repos(path):

    """

    Scans given path for repos and return (name,(type,path)) tuple

    :param path: path to scan for repositories

    :param recursive: recursive search and return names with subdirs in front

    """

    # remove ending slash for better results

    path = path.rstrip(os.sep)

    log.debug('now scanning in %s', path)

    def isdir(*n):

        return os.path.isdir(os.path.join(*n))

    for root, dirs, _files in os.walk(path):

        recurse_dirs = []

        for subdir in dirs:

            # skip removed repos

            if REMOVED_REPO_PAT.match(subdir):

                continue

            # skip .<something> dirs TODO: rly? then we should prevent creating them ...

            if subdir.startswith('.'):

                continue

            cur_path = os.path.join(root, subdir)

            if isdir(cur_path, '.git'):

                log.warning('ignoring non-bare Git repo: %s', cur_path)

                continue

            if (isdir(cur_path, '.hg') or

                isdir(cur_path, '.svn') or

                isdir(cur_path, 'objects') and (isdir(cur_path, 'refs') or

                                                os.path.isfile(os.path.join(cur_path, 'packed-refs')))):

                if not os.access(cur_path, os.R_OK) or not os.access(cur_path, os.X_OK):

                    log.warning('ignoring repo path without access: %s', cur_path)

                    continue

                if not os.access(cur_path, os.W_OK):

                    log.warning('repo path without write access: %s', cur_path)

                try:

                    scm_info = get_scm(cur_path)

                    assert cur_path.startswith(path)

                    repo_path = cur_path[len(path) + 1:]

                    yield repo_path, scm_info

                    continue # no recursion

                except VCSError:

                    # We should perhaps ignore such broken repos, but especially

                    # the bare git detection is unreliable so we dive into it

                    pass

            recurse_dirs.append(subdir)

        dirs[:] = recurse_dirs

def is_valid_repo_uri(repo_type, url, ui):

    """Check if the url seems like a valid remote repo location

    Raise InvalidCloneUriException if any problems"""

    if repo_type == 'hg':

        if url.startswith('http') or url.startswith('ssh'):

            # initially check if it's at least the proper URL

            # or does it pass basic auth

            try:

                MercurialRepository._check_url(url, ui)

            except urllib.error.URLError as e:

                raise InvalidCloneUriException('URI %s URLError: %s' % (url, e))

            except mercurial.error.RepoError as e:

                raise InvalidCloneUriException('Mercurial %s: %s' % (type(e).__name__, safe_str(bytes(e))))

        elif url.startswith('git+http'):

            raise InvalidCloneUriException('URI type %s not implemented' % (url,))

        else:

            raise InvalidCloneUriException('URI %s not allowed' % (url,))

    elif repo_type == 'git':

        if url.startswith('http') or url.startswith('git'):

            # initially check if it's at least the proper URL

            # or does it pass basic auth

            try:

                GitRepository._check_url(url)

            except urllib.error.URLError as e:

                raise InvalidCloneUriException('URI %s URLError: %s' % (url, e))

        elif url.startswith('hg+http'):

            raise InvalidCloneUriException('URI type %s not implemented' % (url,))

        else:

            raise InvalidCloneUriException('URI %s not allowed' % (url))

def is_valid_repo(repo_name, base_path, scm=None):

    """

    Returns True if given path is a valid repository False otherwise.

    If scm param is given also compare if given scm is the same as expected

    from scm parameter

    :param repo_name:

    :param base_path:

    :param scm:

    :return True: if given path is a valid repository

    """

    # TODO: paranoid security checks?

    full_path = os.path.join(base_path, repo_name)

    try:

        scm_ = get_scm(full_path)

        if scm:

            return scm_[0] == scm

        return True

    except VCSError:

        return False

def is_valid_repo_group(repo_group_name, base_path, skip_path_check=False):

    """

    Returns True if given path is a repository group False otherwise

    :param repo_name:

    :param base_path:

    """

    full_path = os.path.join(base_path, repo_group_name)

def set_vcs_config(config):

    """

    Patch VCS config with some Kallithea specific stuff

    :param config: kallithea.CONFIG

    """

    settings.BACKENDS = {

        'hg': 'kallithea.lib.vcs.backends.hg.MercurialRepository',

        'git': 'kallithea.lib.vcs.backends.git.GitRepository',

    }

    settings.GIT_EXECUTABLE_PATH = config.get('git_path', 'git')

    settings.GIT_REV_FILTER = config.get('git_rev_filter', '--all').strip()

    settings.DEFAULT_ENCODINGS = aslist(config.get('default_encoding',

                                                        'utf-8'), sep=',')

def set_indexer_config(config):

    """

    Update Whoosh index mapping

    :param config: kallithea.CONFIG

    """

    log.debug('adding extra into INDEX_EXTENSIONS')

    kallithea.lib.conf.INDEX_EXTENSIONS.extend(re.split(r'\s+', config.get('index.extensions', '')))

    log.debug('adding extra into INDEX_FILENAMES')

    kallithea.lib.conf.INDEX_FILENAMES.extend(re.split(r'\s+', config.get('index.filenames', '')))

def map_groups(path):

    """

    Given a full path to a repository, create all nested groups that this

    repo is inside. This function creates parent-child relationships between

    groups and creates default perms for all new groups.

    :param paths: full path to repository

    """

    from kallithea.model.repo_group import RepoGroupModel

    sa = meta.Session()

    groups = path.split(kallithea.URL_SEP)

    parent = None

    group = None

    # last element is repo in nested groups structure

    groups = groups[:-1]

    rgm = RepoGroupModel()

    owner = db.User.get_first_admin()

    for lvl, group_name in enumerate(groups):

        group_name = '/'.join(groups[:lvl] + [group_name])

        group = db.RepoGroup.get_by_group_name(group_name)

        desc = '%s group' % group_name

        # skip folders that are now removed repos

        if REMOVED_REPO_PAT.match(group_name):

            break

        if group is None:

            log.debug('creating group level: %s group_name: %s',

                      lvl, group_name)

            group = db.RepoGroup(group_name, parent)

            group.group_description = desc

            group.owner = owner

            sa.add(group)

            rgm._create_default_perms(group)

            sa.flush()

        parent = group

    return group

def repo2db_mapper(initial_repo_dict, remove_obsolete=False,

                   install_git_hooks=False, user=None, overwrite_git_hooks=False):

    """

    maps all repos given in initial_repo_dict, non existing repositories

    are created, if remove_obsolete is True it also check for db entries

    that are not in initial_repo_dict and removes them.

    :param initial_repo_dict: mapping with repositories found by scanning methods

    :param remove_obsolete: check for obsolete entries in database

    :param install_git_hooks: if this is True, also check and install git hook

        for a repo if missing

    :param overwrite_git_hooks: if this is True, overwrite any existing git hooks

        that may be encountered (even if user-deployed)

    """

    from kallithea.model.repo import RepoModel

    from kallithea.model.scm import ScmModel

    sa = meta.Session()

    repo_model = RepoModel()

    if user is None:

        user = db.User.get_first_admin()

    added = []

    # creation defaults

    defs = db.Setting.get_default_repo_settings(strip_prefix=True)

    enable_statistics = defs.get('repo_enable_statistics')

    enable_downloads = defs.get('repo_enable_downloads')

    private = defs.get('repo_private')

    for name, repo in sorted(initial_repo_dict.items()):

        group = map_groups(name)

        db_repo = repo_model.get_by_repo_name(name)

        # found repo that is on filesystem not in Kallithea database

        if not db_repo:

            log.info('repository %s not found, creating now', name)

            added.append(name)

            desc = (repo.description

                    if repo.description != 'unknown'

                    else '%s repository' % name)

            try:

                new_repo = repo_model._create_repo(

                    repo_name=name,

                    repo_type=repo.alias,

                    description=desc,

                    repo_group=getattr(group, 'group_id', None),

                    owner=user,

                    enable_downloads=enable_downloads,

                    enable_statistics=enable_statistics,

                    private=private,

                    state=db.Repository.STATE_CREATED

                )

            except Exception as e:

                log.error('error creating %r: %s: %s', name, type(e).__name__, e)

                sa.rollback()

                continue

            sa.commit()

            # we added that repo just now, and make sure it has githook

            # installed, and updated server info

            if new_repo.repo_type == 'git':

                git_repo = new_repo.scm_instance

                ScmModel().install_git_hooks(git_repo)

                # update repository server-info

                log.debug('Running update server info')

                git_repo._update_server_info()