links.append('<a class="message-link" href="%s">%s</a>' % (l, e))

        else:

            links.append(e)

    return ''.join(links)

# Global variable that will hold the actual urlify_issues function body.

# Will be set on first use when the global configuration has been read.

_urlify_issues_f = None

def urlify_issues(newtext, repo_name):

    """Urlify issue references according to .ini configuration"""

    global _urlify_issues_f

    if _urlify_issues_f is None:

        from kallithea import CONFIG

        from kallithea.model.db import URL_SEP

        assert CONFIG['sqlalchemy.url'] # make sure config has been loaded

        # Build chain of urlify functions, starting with not doing any transformation

        tmp_urlify_issues_f = lambda s: s

        issue_pat_re = re.compile(r'issue_pat(.*)')

        for k in CONFIG.keys():

            # Find all issue_pat* settings that also have corresponding server_link and prefix configuration

            m = issue_pat_re.match(k)

            if m is None:

                continue

            suffix = m.group(1)

            issue_pat = CONFIG.get(k)

            issue_server_link = CONFIG.get('issue_server_link%s' % suffix)

            issue_prefix = CONFIG.get('issue_prefix%s' % suffix)

            if not issue_pat or not issue_server_link or issue_prefix is None: # issue_prefix can be empty but should be present

                log.error('skipping incomplete issue pattern %r: %r -> %r %r', suffix, issue_pat, issue_server_link, issue_prefix)

                continue

            # Wrap tmp_urlify_issues_f with substitution of this pattern, while making sure all loop variables (and compiled regexpes) are bound

            try:

                issue_re = re.compile(issue_pat)

            except re.error as e:

                log.error('skipping invalid issue pattern %r: %r -> %r %r. Error: %s', suffix, issue_pat, issue_server_link, issue_prefix, str(e))

                continue

            log.debug('issue pattern %r: %r -> %r %r', suffix, issue_pat, issue_server_link, issue_prefix)

            def issues_replace(match_obj,

                               issue_server_link=issue_server_link, issue_prefix=issue_prefix):

                issue_id = ''.join(match_obj.groups())

                issue_url = issue_server_link.replace('{id}', issue_id)

                issue_url = issue_url.replace('{repo}', repo_name)

                issue_url = issue_url.replace('{repo_name}', repo_name.split(URL_SEP)[-1])

                return (

                    '%(issue-prefix)s%(id-repr)s'

                    '</a>'

                    ) % {

                     'url': issue_url,

                     'id-repr': issue_id,

                     'issue-prefix': issue_prefix,

                     'serv': issue_server_link,

                    }

            tmp_urlify_issues_f = (lambda s,

                                          issue_re=issue_re, issues_replace=issues_replace, chain_f=tmp_urlify_issues_f:

                                   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.

    """

    s = safe_unicode(source)

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

    """

    Return full markup for a href to changeset_home for a changeset.

    If ref_type is branch it will link to changelog.

    ref_name is shortened if ref_type is 'rev'.

    if rev is specified show it too, explicitly linking to that revision.

    """

    txt = short_ref(ref_type, ref_name)

    if ref_type == 'branch':

        u = url('changelog_home', repo_name=repo_name, branch=ref_name)

    else:

        u = url('changeset_home', repo_name=repo_name, revision=ref_name)

    l = link_to(repo_name + '#' + txt, u)

    if rev and ref_type != 'rev':

        l = literal('%s (%s)' % (l, link_to(short_id(rev), url('changeset_home', repo_name=repo_name, revision=rev))))

    return l

<%text>## hide all refs in changelog switch this to --branches --tags</%text>

#git_rev_filter = --branches --tags

<%text>## RSS feed options</%text>

rss_cut_off_limit = 256000

rss_items_per_page = 10

rss_include_diff = false

<%text>## options for showing and identifying changesets</%text>

show_sha_length = 12

show_revision_number = false

<%text>## Canonical URL to use when creating full URLs in UI and texts.</%text>

<%text>## Useful when the site is available under different names or protocols.</%text>

<%text>## Defaults to what is provided in the WSGI environment.</%text>

#canonical_url = https://kallithea.example.com/repos

<%text>## gist URL alias, used to create nicer urls for gist. This should be an</%text>

<%text>## url that does rewrites to _admin/gists/<gistid>.</%text>

<%text>## example: http://gist.example.com/{gistid}. Empty means use the internal</%text>

<%text>## Kallithea url, ie. http[s]://kallithea.example.com/_admin/gists/<gistid></%text>

gist_alias_url =

<%text>## white list of API enabled controllers. This allows to add list of</%text>

<%text>## controllers to which access will be enabled by api_key. eg: to enable</%text>

<%text>## api access to raw_files put `FilesController:raw`, to enable access to patches</%text>

<%text>## add `ChangesetController:changeset_patch`. This list should be "," separated</%text>

<%text>## Syntax is <ControllerClass>:<function>. Check debug logs for generated names</%text>

<%text>## Recommended settings below are commented out:</%text>

api_access_controllers_whitelist =

#    ChangesetController:changeset_patch,

#    ChangesetController:changeset_raw,

#    FilesController:raw,

#    FilesController:archivefile

<%text>## default encoding used to convert from and to unicode</%text>

<%text>## can be also a comma separated list of encoding in case of mixed encodings</%text>

default_encoding = utf8

<%text>## issue tracker for Kallithea (leave blank to disable, absent for default)</%text>

#bugtracker = https://bitbucket.org/conservancy/kallithea/issues

<%text>## issue tracking mapping for commits messages</%text>

<%text>## comment out issue_pat, issue_server, issue_prefix to enable</%text>

<%text>## pattern to get the issues from commit messages</%text>

<%text>## default one used here is #<numbers> with a regex passive group for `#`</%text>

<%text>## {id} will be all groups matched from this pattern</%text>

issue_pat = #(\d+)

<%text>## server url to the issue, each {id} will be replaced with match</%text>

<%text>## fetched from the regex and {repo} is replaced with full repository name</%text>

<%text>## including groups {repo_name} is replaced with just name of repo</%text>

issue_server_link = https://issues.example.com/{repo}/issue/{id}

<%text>## prefix to add to link to indicate it's an url</%text>

<%text>## #314 will be replaced by <issue_prefix><id></%text>

issue_prefix = #

<%text>## issue_pat, issue_server_link, issue_prefix can have suffixes to specify</%text>

<%text>## multiple patterns, to other issues server, wiki or others</%text>

<%text>## below an example how to create a wiki pattern</%text>

# wiki-some-id -> https://wiki.example.com/some-id

#issue_pat_wiki = (?:wiki-)(.+)

#issue_server_link_wiki = https://wiki.example.com/{id}

#issue_prefix_wiki = WIKI-

<%text>## alternative return HTTP header for failed authentication. Default HTTP</%text>

<%text>## response is 401 HTTPUnauthorized. Currently Mercurial clients have trouble with</%text>

<%text>## handling that. Set this variable to 403 to return HTTPForbidden</%text>

auth_ret_code =

<%text>## locking return code. When repository is locked return this HTTP code. 2XX</%text>

<%text>## codes don't break the transactions while 4XX codes do</%text>

lock_ret_code = 423

<%text>## allows to change the repository location in settings page</%text>

allow_repo_location_change = True

<%text>## allows to setup custom hooks in settings page</%text>

allow_custom_hooks_settings = True

<%text>## extra extensions for indexing, space separated and without the leading '.'.</%text>

# index.extensions =

#    gemfile

#    lock

<%text>## extra filenames for indexing, space separated</%text>

# index.filenames =

#    .dockerignore

#    .editorconfig

#    INSTALL

       ""),

      ("deadbeefcafe 123412341234",

       """<a class="changeset_hash" href="/repo_name/changeset/deadbeefcafe">deadbeefcafe</a> <a class="changeset_hash" href="/repo_name/changeset/123412341234">123412341234</a>""",

       ""),

      ("We support * markup for *bold* markup of *single or multiple* words, "

       "*a bit @like http://slack.com*. "

       "The first * must come after whitespace and not be followed by whitespace, "

       "contain anything but * and newline until the next *, "

       "which must not come after whitespace "

       "and not be followed by * or alphanumerical *characters*.",

       """We support * markup for <b>*bold*</b> markup of <b>*single or multiple*</b> words, """

       """<b>*a bit <b>@like</b> <a href="http://slack.com">http://slack.com</a>*</b>. """

       """The first * must come after whitespace and not be followed by whitespace, """

       """contain anything but * and newline until the next *, """

       """which must not come after whitespace """

       """and not be followed by * or alphanumerical <b>*characters*</b>.""",

       "-"),

      ("HTML escaping: <abc> 'single' \"double\" &pointer",

       "HTML escaping: <abc> 'single' "double" &pointer",

       "-"),

      # tags are covered by test_tag_extractor

    ])

    def test_urlify_test(self, sample, expected, url_):

        expected = self._quick_url(expected,

                                   tmpl="""<a href="%s">%s</a>""", url_=url_)

        fake_url = FakeUrlGenerator(changeset_home='/%(repo_name)s/changeset/%(revision)s')

        with mock.patch('kallithea.config.routing.url', fake_url):

            from kallithea.lib.helpers import urlify_text

            assert urlify_text(sample, 'repo_name', stylize=True) == expected

    @parametrize('sample,expected', [

      ("deadbeefcafe @mention, and http://foo.bar/ yo",

       """<a class="changeset_hash" href="/repo_name/changeset/deadbeefcafe">deadbeefcafe</a>"""

       """<a class="message-link" href="#the-link"> <b>@mention</b>, and </a>"""

       """<a href="http://foo.bar/">http://foo.bar/</a>"""

       """<a class="message-link" href="#the-link"> yo</a>"""),

    ])

    def test_urlify_link(self, sample, expected):

        fake_url = FakeUrlGenerator(changeset_home='/%(repo_name)s/changeset/%(revision)s')

        with mock.patch('kallithea.config.routing.url', fake_url):

            from kallithea.lib.helpers import urlify_text

            assert urlify_text(sample, 'repo_name', link_='#the-link') == expected

    @parametrize('issue_pat,issue_server,issue_prefix,sample,expected', [

        (r'#(\d+)', 'http://foo/{repo}/issue/{id}', '#',

            'issue #123 and issue#456',

            """issue <a class="issue-tracker-link" href="http://foo/repo_name/issue/123">#123</a> and """

            """issue<a class="issue-tracker-link" href="http://foo/repo_name/issue/456">#456</a>"""),

        (r'(?:\s*#)(\d+)', 'http://foo/{repo}/issue/{id}', '#',

            'issue #123 and issue#456',

            """issue<a class="issue-tracker-link" href="http://foo/repo_name/issue/456">#456</a>"""),

        (r'\bPR(\d+)', 'http://foo/{repo}/issue/{id}', '#',

            'issue PR123 and issuePR456',

            """issue <a class="issue-tracker-link" href="http://foo/repo_name/issue/123">#123</a> and """

            """issuePR456"""),

        # are reversed from what is actually happening.

        (r'\b#(\d+)', 'http://foo/{repo}/issue/{id}', '#',

            'issue #123 and issue#456',

            """issue #123 and """

            """issue<a class="issue-tracker-link" href="http://foo/repo_name/issue/456">#456</a>"""),

            """issue <a class="issue-tracker-link" href="http://foo/repo_name/issue/123">#123</a> and """

            """issue#456"""),

        (r'(?:pullrequest|pull request|PR|pr) ?#?(\d+)', 'http://foo/{repo}/issue/{id}', 'PR#',

            'fixed with pullrequest #1, pull request#2, PR 3, pr4',

            """fixed with <a class="issue-tracker-link" href="http://foo/repo_name/issue/1">PR#1</a>, """

            """<a class="issue-tracker-link" href="http://foo/repo_name/issue/2">PR#2</a>, """

            """<a class="issue-tracker-link" href="http://foo/repo_name/issue/3">PR#3</a>, """

            """<a class="issue-tracker-link" href="http://foo/repo_name/issue/4">PR#4</a>"""),

        (r'#(\d+)', 'http://foo/{repo}/issue/{id}', 'PR',

            'interesting issue #123',

            """interesting issue <a class="issue-tracker-link" href="http://foo/repo_name/issue/123">PR123</a>"""),

        (r'BUG\d{5}', 'https://bar/{repo}/{id}', 'BUG',

            'silly me, I did not parenthesize the {id}, BUG12345.',

            """silly me, I did not parenthesize the {id}, <a class="issue-tracker-link" href="https://bar/repo_name/">BUG</a>."""),

        (r'BUG(\d{5})', 'https://bar/{repo}/', 'BUG',

            'silly me, the URL does not contain {id}, BUG12345.',

            """silly me, the URL does not contain {id}, <a class="issue-tracker-link" href="https://bar/repo_name/">BUG12345</a>."""),

        (r'(PR-\d+)', 'http://foo/{repo}/issue/{id}', '',

            'interesting issue #123, err PR-56',

            """interesting issue #123, err <a class="issue-tracker-link" href="http://foo/repo_name/issue/PR-56">PR-56</a>"""),

        (r'#(\d+)', 'http://foo/{repo}/issue/{id}', '#',

            "some 'standard' text with apostrophes",

            """some 'standard' text with apostrophes"""),

        (r'#(\d+)', 'http://foo/{repo}/issue/{id}', '#',

            "some 'standard' issue #123",

            """some &#39;standard&#39; issue <a class="issue-tracker-link" href="http://foo/repo_name/issue/123">#123</a>"""),

        (r'#(\d+)', 'http://foo/{repo}/issue/{id}', '#',

            'an issue   #123       with extra whitespace',

            """an issue   <a class="issue-tracker-link" href="http://foo/repo_name/issue/123">#123</a>       with extra whitespace"""),

        # Note: whitespace is squashed

        (r'(?:\s*#)(\d+)', 'http://foo/{repo}/issue/{id}', '#',

            'an issue   #123       with extra whitespace',

            """an issue <a class="issue-tracker-link" href="http://foo/repo_name/issue/123">#123</a>       with extra whitespace"""),

        # invalid issue pattern

        (r'(PR\d+', 'http://foo/{repo}/issue/{id}', '',

            'PR135',

            """PR135"""),

    ])

    def test_urlify_issues(self, issue_pat, issue_server, issue_prefix, sample, expected):

        from kallithea.lib.helpers import urlify_text

        config_stub = {

            'sqlalchemy.url': 'foo',

            'issue_pat': issue_pat,

            'issue_server_link': issue_server,

            'issue_prefix': issue_prefix,

        }

        # force recreation of lazy function

        with mock.patch('kallithea.lib.helpers._urlify_issues_f', None):