return (

                    '<a class="issue-tracker-link" href="%(url)s">'

                    '%(text)s'

                    '</a>'

                    ) % {

                     'url': issue_url,

                     'text': issue_text,

                    }

            def tmp_urlify_issues_f(s, issue_re=issue_re, issues_replace=issues_replace, chain_f=tmp_urlify_issues_f):

                return issue_re.sub(issues_replace, chain_f(s))

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

    """

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

def changeset_status(repo, revision):

    return ChangesetStatusModel().get_status(repo, revision)

def changeset_status_lbl(changeset_status):

    return db.ChangesetStatus.get_status_lbl(changeset_status)

def get_permission_name(key):

    return dict(db.Permission.PERMS).get(key)

def journal_filter_help():

    return _(textwrap.dedent('''

        Example filter terms:

            repository:vcs

            username:developer

            action:*push*

            ip:127.0.0.1

            date:20120101

            date:[20120101100000 TO 20120102]

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

        """

        """

        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