import formencode.htmlfill

from sqlalchemy.sql.expression import or_

from tg import request, response

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPForbidden, HTTPFound, HTTPNotFound

from kallithea.config.routing import url

from kallithea.lib import helpers as h

from kallithea.lib.auth import LoginRequired

from kallithea.lib.base import BaseController, jsonify, render

from kallithea.lib.page import Page

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

from kallithea.model.db import Gist

from kallithea.model.forms import GistForm

from kallithea.model.gist import GistModel

from kallithea.model.meta import Session

log = logging.getLogger(__name__)

class GistsController(BaseController):

    """REST Controller styled on the Atom Publishing Protocol"""

        if c.gist.is_expired:

            log.error('Gist expired at %s',

                      time_to_datetime(c.gist.gist_expires))

            raise HTTPNotFound()

        try:

            c.file_changeset, c.files = GistModel().get_gist_files(gist_id,

                                                            revision=revision)

        except VCSError:

            log.error(traceback.format_exc())

            raise HTTPNotFound()

        if format == 'raw':

            content = '\n\n'.join(

                for f in c.files if (f_path is None or f.path == f_path)

            )

            response.content_type = 'text/plain'

            return content

        return render('admin/gists/show.html')

    @LoginRequired()

    def edit(self, gist_id, format='html'):

        c.gist = Gist.get_or_404(gist_id)

        if c.gist.is_expired:

            log.error('Gist expired at %s',

from tg import config, request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPFound

from kallithea.config.routing import url

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasPermissionAnyDecorator, LoginRequired

from kallithea.lib.base import BaseController, render

from kallithea.lib.celerylib import tasks

from kallithea.lib.exceptions import HgsubversionImportError

from kallithea.lib.utils import repo2db_mapper, set_app_settings

from kallithea.lib.vcs import VCSError

from kallithea.model.db import Repository, Setting, Ui

from kallithea.model.forms import ApplicationSettingsForm, ApplicationUiSettingsForm, ApplicationVisualisationForm

from kallithea.model.meta import Session

from kallithea.model.notification import EmailNotificationModel

from kallithea.model.scm import ScmModel

log = logging.getLogger(__name__)

class SettingsController(BaseController):

            overwrite_git_hooks = request.POST.get('hooks_overwrite', False)

            invalidate_cache = request.POST.get('invalidate', False)

            log.debug('rescanning repo location with destroy obsolete=%s, '

                      'install git hooks=%s and '

                      'overwrite git hooks=%s' % (rm_obsolete, install_git_hooks, overwrite_git_hooks))

            filesystem_repos = ScmModel().repo_scan()

            added, removed = repo2db_mapper(filesystem_repos, rm_obsolete,

                                            install_git_hooks=install_git_hooks,

                                            user=request.authuser.username,

                                            overwrite_git_hooks=overwrite_git_hooks)

            added_msg = h.HTML(', ').join(

            ) or '-'

            removed_msg = h.HTML(', ').join(

            ) or '-'

            h.flash(h.HTML(_('Repositories successfully rescanned. Added: %s. Removed: %s.')) %

                    (added_msg, removed_msg), category='success')

            if invalidate_cache:

                log.debug('invalidating all repositories cache')

                i = 0

                for repo in Repository.query():

                    try:

                        ScmModel().mark_for_invalidation(repo.repo_name)

                        i += 1

                    except VCSError as e:

from sqlalchemy.sql.expression import func

from tg import app_globals, request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPFound, HTTPInternalServerError

from kallithea.config.routing import url

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasPermissionAnyDecorator, HasUserGroupPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseController, render

from kallithea.lib.exceptions import RepoGroupAssignmentError, UserGroupsAssignedException

from kallithea.lib.utils import action_logger

from kallithea.model.db import User, UserGroup, UserGroupRepoGroupToPerm, UserGroupRepoToPerm, UserGroupToPerm

from kallithea.model.forms import CustomDefaultPermissionsForm, UserGroupForm, UserGroupPermsForm

from kallithea.model.meta import Session

from kallithea.model.scm import UserGroupList

from kallithea.model.user_group import UserGroupModel

log = logging.getLogger(__name__)

class UserGroupsController(BaseController):

    """REST Controller styled on the Atom Publishing Protocol"""

        raise HTTPFound(location=url('users_groups'))

    @HasPermissionAnyDecorator('hg.admin', 'hg.usergroup.create.true')

    def new(self, format='html'):

        return render('admin/user_groups/user_group_add.html')

    @HasUserGroupPermissionLevelDecorator('admin')

    def update(self, id):

        c.user_group = UserGroup.get_or_404(id)

        c.active = 'settings'

        self.__load_data(id)

        users_group_form = UserGroupForm(edit=True,

                                         old_data=c.user_group.get_dict(),

                                         available_members=available_members)()

        try:

            form_result = users_group_form.to_python(request.POST)

            UserGroupModel().update(c.user_group, form_result)

            gr = form_result['users_group_name']

            action_logger(request.authuser,

                          'admin_updated_users_group:%s' % gr,

                          None, request.ip_addr)

from tg import request, response

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPBadRequest, HTTPForbidden, HTTPFound, HTTPNotFound

import kallithea.lib.helpers as h

from kallithea.lib import diffs

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseRepoController, jsonify, render

from kallithea.lib.graphmod import graph_data

from kallithea.lib.utils import action_logger

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

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError, EmptyRepositoryError, RepositoryError

from kallithea.model.changeset_status import ChangesetStatusModel

from kallithea.model.comment import ChangesetCommentsModel

from kallithea.model.db import ChangesetComment, ChangesetStatus

from kallithea.model.meta import Session

from kallithea.model.pull_request import PullRequestModel

log = logging.getLogger(__name__)

            c.changeset = c.cs_ranges[0]

            c.parent_tmpl = ''.join(['# Parent  %s\n' % x.raw_id

                                     for x in c.changeset.parents])

            c.changeset_graft_source_hash = ascii_str(c.changeset.extra.get(b'source', b''))

            c.changeset_transplant_source_hash = ascii_str(binascii.hexlify(c.changeset.extra.get(b'transplant_source', b'')))

        if method == 'download':

            response.content_type = 'text/plain'

            response.content_disposition = 'attachment; filename=%s.diff' \

                                            % revision[:12]

            return raw_diff

        elif method == 'patch':

            response.content_type = 'text/plain'

            return render('changeset/patch_changeset.html')

        elif method == 'raw':

            response.content_type = 'text/plain'

            return raw_diff

        elif method == 'show':

            if len(c.cs_ranges) == 1:

                return render('changeset/changeset.html')

            else:

                c.cs_ranges_org = None

                c.cs_comments = {}

                revs = [ctx.revision for ctx in reversed(c.cs_ranges)]

                c.jsdata = graph_data(c.db_repo_scm_instance, revs)

from beaker.cache import cache_region

from tg import response

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from kallithea import CONFIG

from kallithea.lib import feeds

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseRepoController

from kallithea.lib.diffs import DiffProcessor

log = logging.getLogger(__name__)

class FeedController(BaseRepoController):

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def _before(self, *args, **kwargs):

        super(FeedController, self)._before(*args, **kwargs)

        # rev link

        _url = h.canonical_url('changeset_home', repo_name=c.db_repo.repo_name,

                   revision=cs.raw_id)

        desc_msg.append('changeset: <a href="%s">%s</a>' % (_url, cs.raw_id[:8]))

        desc_msg.append('<pre>')

        desc_msg.append(h.urlify_text(cs.message))

        desc_msg.append('\n')

        desc_msg.extend(changes)

        if str2bool(CONFIG.get('rss_include_diff', False)):

            desc_msg.append('\n\n')

        desc_msg.append('</pre>')

        return desc_msg

    def _feed(self, repo_name, feeder):

        """Produce a simple feed"""

        @cache_region('long_term', '_get_feed_from_cache')

        def _get_feed_from_cache(*_cache_keys):  # parameters are not really used - only as caching key

            header = dict(

                title=_('%s %s feed') % (c.site_name, repo_name),

                link=h.canonical_url('summary_home', repo_name=repo_name),

                description=_('Changes on %s repository') % repo_name,

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPFound, HTTPNotFound

from kallithea.config.routing import url

from kallithea.controllers.changeset import _context_url, _ignorews_url, anchor_url, get_ignore_ws, get_line_ctx

from kallithea.lib import diffs

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseRepoController, jsonify, render

from kallithea.lib.exceptions import NonRelativePathError

from kallithea.lib.utils import action_logger

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

from kallithea.lib.vcs.conf import settings

from kallithea.lib.vcs.exceptions import (

    ChangesetDoesNotExistError, ChangesetError, EmptyRepositoryError, ImproperArchiveTypeError, NodeAlreadyExistsError, NodeDoesNotExistError, NodeError, RepositoryError, VCSError)

from kallithea.lib.vcs.nodes import FileNode

from kallithea.model.db import Repository

from kallithea.model.repo import RepoModel

from kallithea.model.scm import ScmModel

log = logging.getLogger(__name__)

        r_post = request.POST

        c.cs = self.__get_cs(revision)

        c.file = self.__get_filenode(c.cs, f_path)

        if c.file.is_binary:

            raise HTTPFound(location=url('files_home', repo_name=c.repo_name,

                            revision=c.cs.raw_id, f_path=f_path))

        c.default_message = _('Edited file %s via Kallithea') % (f_path)

        c.f_path = f_path

        if r_post:

            sl = old_content.splitlines(1)

            first_line = sl[0] if sl else ''

            # modes:  0 - Unix, 1 - Mac, 2 - DOS

            mode = detect_mode(first_line, 0)

            content = convert_line_endings(r_post.get('content', ''), mode)

            message = r_post.get('message') or c.default_message

            author = request.authuser.full_contact

            if content == old_content:

                h.flash(_('No changes'), category='warning')

                raise HTTPFound(location=url('changeset_home', repo_name=c.repo_name,

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPBadRequest

import kallithea.lib.helpers as h

from kallithea.config.conf import ALL_EXTS, ALL_READMES, LANGUAGES_EXTENSIONS_MAP

from kallithea.lib import ext_json

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseRepoController, jsonify, render

from kallithea.lib.celerylib.tasks import get_commits_stats

from kallithea.lib.markup_renderer import MarkupRenderer

from kallithea.lib.page import Page

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

from kallithea.lib.vcs.exceptions import ChangesetError, EmptyRepositoryError, NodeDoesNotExistError

from kallithea.lib.vcs.nodes import FileNode

from kallithea.model.db import Statistics

log = logging.getLogger(__name__)

README_FILES = [''.join([x[0][0], x[1][0]]) for x in

                    sorted(list(itertools.product(ALL_READMES, ALL_EXTS)),

                           key=lambda y:y[0][1] + y[1][1])]

                cs = db_repo.get_landing_changeset()

                if isinstance(cs, EmptyChangeset):

                    raise EmptyRepositoryError()

                renderer = MarkupRenderer()

                for f in README_FILES:

                    try:

                        readme = cs.get_node(f)

                        if not isinstance(readme, FileNode):

                            continue

                        readme_file = f

                        log.debug('Found README file `%s` rendering...',

                                  readme_file)

                                                      filename=f)

                        break

                    except NodeDoesNotExistError:

                        continue

            except ChangesetError:

                log.error(traceback.format_exc())

                pass

            except EmptyRepositoryError:

                pass

            return readme_data, readme_file

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

:created_on: Dec 4, 2011

:author: marcink

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

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

"""

from pygments import highlight

from pygments.formatters import HtmlFormatter

from kallithea.lib.vcs.exceptions import VCSError

from kallithea.lib.vcs.nodes import FileNode

def annotate_highlight(filenode, annotate_from_changeset_func,

        order=None, headers=None, **options):

    """

    Returns html portion containing annotated table with 3 columns: line

    numbers, changeset information and pygmentized line of code.

    :param filenode: FileNode object

    :param annotate_from_changeset_func: function taking changeset and

      returning single annotate cell; needs break line at the end

    :param order: ordered sequence of ``ls`` (line numbers column),

      ``annotate`` (annotate column), ``code`` (code column); Default is

      ``['ls', 'annotate', 'code']``

    :param headers: dictionary with headers (keys are whats in ``order``

      parameter)

    """

    from kallithea.lib.pygmentsutils import get_custom_lexer

    options['linenos'] = True

    formatter = AnnotateHtmlFormatter(filenode=filenode,

        annotate_from_changeset_func=annotate_from_changeset_func, order=order,

        headers=headers, **options)

    lexer = get_custom_lexer(filenode.extension) or filenode.lexer

    return highlighted

class AnnotateHtmlFormatter(HtmlFormatter):

    def __init__(self, filenode, annotate_from_changeset_func,

            order=None, **options):

        """

        ``annotate_from_changeset_func`` must be a function

        which returns string from the given changeset. For example, we may pass

        following function as ``annotate_from_changeset_func``::

import paste.httpheaders

import webob.exc

from tg import TGController, config, render_template, request, response, session

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from kallithea import BACKENDS, __version__

from kallithea.config.routing import url

from kallithea.lib import auth_modules, ext_json

from kallithea.lib.auth import AuthUser, HasPermissionAnyMiddleware

from kallithea.lib.exceptions import UserCreationError

from kallithea.lib.utils import get_repo_slug, is_valid_repo

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError, EmptyRepositoryError, RepositoryError

from kallithea.model import meta

from kallithea.model.db import PullRequest, Repository, Setting, User

from kallithea.model.scm import ScmModel

log = logging.getLogger(__name__)

def render(template_path):

    return render_template({'url': url}, 'mako', template_path)

        return _filter_proxy(ip)

    ip = environ.get(def_key, '0.0.0.0')

    return _filter_proxy(ip)

def get_path_info(environ):

    """Return unicode PATH_INFO from environ ... using tg.original_request if available.

    """

    org_req = environ.get('tg.original_request')

    if org_req is not None:

        environ = org_req.environ

def log_in_user(user, remember, is_external_auth, ip_addr):

    """

    Log a `User` in and update session and cookies. If `remember` is True,

    the session cookie is set to expire in a year; otherwise, it expires at

    the end of the browser session.

    Returns populated `AuthUser` object.

    """

    # It should not be possible to explicitly log in as the default user.

    assert not user.is_default_user, user

:created_on: Dec 4, 2011

:author: marcink

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

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

"""

import difflib

import logging

import re

from tg.i18n import ugettext as _

from kallithea.lib import helpers as h

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

from kallithea.lib.vcs.exceptions import VCSError

from kallithea.lib.vcs.nodes import FileNode, SubModuleNode

log = logging.getLogger(__name__)

def _safe_id(idstring):

    r"""Make a string safe for including in an id attribute.

    The HTML spec says that id attributes 'must begin with

        if groups[1]:

            return '<'

        if groups[2]:

            return '>'

        if groups[3]:

            return '<u>\t</u>'

        if groups[4]:

            return '<u class="cr"></u>'

        if groups[5]:

            return ' <i></i>'

        assert False

_git_header_re = re.compile(br"""

    ^diff[ ]--git[ ]a/(?P<a_path>.+?)[ ]b/(?P<b_path>.+?)\n

    (?:^old[ ]mode[ ](?P<old_mode>\d+)\n

       ^new[ ]mode[ ](?P<new_mode>\d+)(?:\n|$))?

    (?:^similarity[ ]index[ ](?P<similarity_index>\d+)%\n

       ^rename[ ]from[ ](?P<rename_from>.+)\n

       ^rename[ ]to[ ](?P<rename_to>.+)(?:\n|$))?

    (?:^new[ ]file[ ]mode[ ](?P<new_file_mode>.+)(?:\n|$))?

    (?:^deleted[ ]file[ ]mode[ ](?P<deleted_file_mode>.+)(?:\n|$))?

    (?:^index[ ](?P<a_blob_id>[0-9A-Fa-f]+)

from webhelpers2.text import chop_at, truncate, wrap_paragraphs

from kallithea.config.routing import url

from kallithea.lib.annotate import annotate_highlight

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

# PERMS

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

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

from kallithea.lib.markup_renderer import url_re

from kallithea.lib.pygmentsutils import get_custom_lexer

from kallithea.lib.utils2 import MENTIONS_REGEX, AttributeDict

from kallithea.lib.utils2 import age as _age

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

log = logging.getLogger(__name__)

def canonical_url(*args, **kargs):

def markup_whitespace(s):

    return _whitespace_re.sub(_markup_whitespace, s)

def pygmentize(filenode, **kwargs):

    """

    pygmentize function using pygments

    :param filenode:

    """

    lexer = get_custom_lexer(filenode.extension) or filenode.lexer

    return literal(markup_whitespace(

def hsv_to_rgb(h, s, v):

    if s == 0.0:

        return v, v, v

    i = int(h * 6.0)  # XXX assume int() truncates!

    f = (h * 6.0) - i

    p = v * (1.0 - s)

    q = v * (1.0 - s * f)

    t = v * (1.0 - s * (1.0 - f))

    i = i % 6

    if i == 0:

        # Set tmp function globally - atomically

        _urlify_issues_f = tmp_urlify_issues_f

    return _urlify_issues_f(newtext)

def render_w_mentions(source, repo_name=None):

    """

    Render plain text with revision hashes and issue references urlified

    and with @mention highlighting.

    """

    s = urlify_text(s, repo_name=repo_name)

    return literal('<div class="formatted-fixed">%s</div>' % s)

def short_ref(ref_type, ref_name):

    if ref_type == 'rev':

        return short_id(ref_name)

    return ref_name

def link_to_ref(repo_name, ref_type, ref_name, rev=None):

    """

import os

import sys

import traceback

from os.path import dirname

from shutil import rmtree

from time import mktime

from whoosh.index import create_in, exists_in, open_dir

from whoosh.qparser import QueryParser

from kallithea.config.conf import INDEX_EXTENSIONS, INDEX_FILENAMES

from kallithea.lib.indexers import CHGSET_IDX_NAME, CHGSETS_SCHEMA, IDX_NAME, SCHEMA

from kallithea.lib.vcs.exceptions import ChangesetError, NodeDoesNotExistError, RepositoryError

from kallithea.model.db import Repository

from kallithea.model.scm import ScmModel

# Add location of top level folder to sys.path

project_path = dirname(dirname(dirname(dirname(os.path.realpath(__file__)))))

sys.path.append(project_path)

        except (ChangesetError, NodeDoesNotExistError):

            log.debug("    >> %s - not found in %s %s", path, repo, index_rev)

            return 0, 0

        indexed = indexed_w_content = 0

        if self.is_indexable_node(node):

            bytes_content = node.content

            if b'\0' in bytes_content:

                log.warning('    >> %s - no text content', path)

                u_content = u''

            else:

                log.debug('    >> %s', path)

                indexed_w_content += 1

        else:

            log.debug('    >> %s - not indexable', path)

            # just index file name without it's content

            u_content = u''

            indexed += 1

        writer.add_document(

            fileid=path,

            owner=repo.contact,

            repository_rawname=repo_name,

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

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

"""

import logging

import re

import traceback

import bleach

import markdown as markdown_mod

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']

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

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

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

        u'<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:

            from docutils.core import publish_parts

            from docutils.parsers.rst import directives

            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)

# 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.middleware.permanent_repo_url

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

middleware to handle permanent repo URLs, replacing PATH_INFO '/_123/yada' with

'/name/of/repo/yada' after looking 123 up in the database.

"""

from kallithea.lib.utils import fix_repo_id_name

class PermanentRepoUrl(object):

    def __init__(self, app, config):

        self.application = app

        self.config = config

    def __call__(self, environ, start_response):

        # Extract path_info as get_path_info does, but do it explicitly because

        # we also have to do the reverse operation when patching it back in

        if path_info.startswith('/'): # it must

            path_info = '/' + fix_repo_id_name(path_info[1:])

            environ['PATH_INFO'] = safe_bytes(path_info)

        return self.application(environ, start_response)

import json

import os

import pwd

import re