if stats['binary']:

        # binary mode

        lbl = ''

        bin_op = 1

        if BIN_FILENODE in stats['ops']:

            lbl = 'bin+'

        if NEW_FILENODE in stats['ops']:

            lbl += _('new file')

            bin_op = NEW_FILENODE

        elif MOD_FILENODE in stats['ops']:

            lbl += _('mod')

            bin_op = MOD_FILENODE

        elif DEL_FILENODE in stats['ops']:

            lbl += _('del')

            bin_op = DEL_FILENODE

        elif RENAMED_FILENODE in stats['ops']:

            lbl += _('rename')

            bin_op = RENAMED_FILENODE

        # chmod can go with other operations

        if CHMOD_FILENODE in stats['ops']:

            _org_lbl = _('chmod')

            lbl += _org_lbl if lbl.endswith('+') else '+%s' % _org_lbl

        #import ipdb;ipdb.set_trace()

        b_d = '<div class="bin bin%s progress-bar" style="width:100%%">%s</div>' % (bin_op, lbl)

        b_a = '<div class="bin bin1" style="width:0%"></div>'

        return literal('<div style="width:%spx" class="progress">%s%s</div>' % (width, b_a, b_d))

    t = stats['added'] + stats['deleted']

    unit = float(width) / (t or 1)

    # needs > 9% of width to be visible or 0 to be hidden

    a_p = max(9, unit * a) if a > 0 else 0

    d_p = max(9, unit * d) if d > 0 else 0

    p_sum = a_p + d_p

    if p_sum > width:

        # adjust the percentage to be == 100% since we adjusted to 9

        if a_p > d_p:

            a_p = a_p - (p_sum - width)

        else:

            d_p = d_p - (p_sum - width)

    a_v = a if a > 0 else ''

    d_v = d if d > 0 else ''

    d_a = '<div class="added progress-bar" style="width:%s%%">%s</div>' % (

        a_p, a_v

    )

    d_d = '<div class="deleted progress-bar" style="width:%s%%">%s</div>' % (

        d_p, d_v

    )

    return literal('<div class="progress" style="width:%spx">%s%s</div>' % (width, d_a, d_d))

_URLIFY_RE = re.compile(r'''

# URL markup

(?P<url>%s) |

# @mention markup

(?P<mention>%s) |

# Changeset hash markup

(?<!\w|[-_])

  (?P<hash>[0-9a-f]{12,40})

(?!\w|[-_]) |

# Markup of *bold text*

(?:

  (?:^|(?<=\s))

  (?P<bold> [*] (?!\s) [^*\n]* (?<!\s) [*] )

  (?![*\w])

) |

# "Stylize" markup

\[see\ \=&gt;\ *(?P<seen>[a-zA-Z0-9\/\=\?\&\ \:\/\.\-]*)\] |

\[license\ \=&gt;\ *(?P<license>[a-zA-Z0-9\/\=\?\&\ \:\/\.\-]*)\] |

\[(?P<tagtype>requires|recommends|conflicts|base)\ \=&gt;\ *(?P<tagvalue>[a-zA-Z0-9\-\/]*)\] |

\[(?:lang|language)\ \=&gt;\ *(?P<lang>[a-zA-Z\-\/\#\+]*)\] |

\[(?P<tag>[a-z]+)\]

''' % (url_re.pattern, MENTIONS_REGEX.pattern),

    re.VERBOSE | re.MULTILINE | re.IGNORECASE)

def urlify_text(s, repo_name=None, link_=None, truncate=None, stylize=False, truncatef=truncate):

    """

    Parses given text message and make literal html with markup.

    The text will be truncated to the specified length.

    Hashes are turned into changeset links to specified repository.

    URLs links to what they say.

    Issues are linked to given issue-server.

    If link_ is provided, all text not already linking somewhere will link there.

    """

    def _replace(match_obj):

        url = match_obj.group('url')

        if url is not None:

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

        mention = match_obj.group('mention')

        if mention is not None:

            return '<b>%s</b>' % mention

        hash_ = match_obj.group('hash')

        if hash_ is not None and repo_name is not None:

            from kallithea.config.routing import url  # doh, we need to re-import url to mock it later

            return '<a class="changeset_hash" href="%(url)s">%(hash)s</a>' % {

                 'url': url('changeset_home', repo_name=repo_name, revision=hash_),

                 'hash': hash_,

                }

        bold = match_obj.group('bold')

        if bold is not None:

            return '<b>*%s*</b>' % _urlify(bold[1:-1])

        if stylize:

            seen = match_obj.group('seen')

            if seen:

                return '<div class="label label-meta" data-tag="see">see =&gt; %s</div>' % seen

            license = match_obj.group('license')

            if license:

                return '<div class="label label-meta" data-tag="license"><a href="http:\/\/www.opensource.org/licenses/%s">%s</a></div>' % (license, license)

            tagtype = match_obj.group('tagtype')

            if tagtype:

                tagvalue = match_obj.group('tagvalue')

                return '<div class="label label-meta" data-tag="%s">%s =&gt; <a href="/%s">%s</a></div>' % (tagtype, tagtype, tagvalue, tagvalue)

            lang = match_obj.group('lang')

            if lang:

                return '<div class="label label-meta" data-tag="lang">%s</div>' % lang

            tag = match_obj.group('tag')

            if tag:

                return '<div class="label label-meta" data-tag="%s">%s</div>' % (tag, tag)

        return match_obj.group(0)

    def _urlify(s):

        """

        Extract urls from text and make html links out of them

        """

        return _URLIFY_RE.sub(_replace, s)

    if truncate is None:

        s = s.rstrip()

    else:

        s = truncatef(s, truncate, whole_word=True)

    s = html_escape(s)

    s = _urlify(s)

    if repo_name is not None:

        s = urlify_issues(s, repo_name)

    if link_ is not None:

        # make href around everything that isn't a href already

        s = linkify_others(s, link_)

    s = s.replace('\r\n', '<br/>').replace('\n', '<br/>')

    return literal(s)

def linkify_others(t, l):

    """Add a default link to html with links.

    HTML doesn't allow nesting of links, so the outer link must be broken up

    in pieces and give space for other links.

    """

    urls = re.compile(r'(\<a.*?\<\/a\>)',)

    links = []

    for e in urls.split(t):

        if e.strip() and not urls.match(e):

            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)

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

            else:

                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

            issue_re = re.compile(issue_pat)

            def issues_replace(match_obj,

                               issue_server_link=issue_server_link, issue_prefix=issue_prefix):

                leadingspace = ' ' if match_obj.group().startswith(' ') else ''

                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 (

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

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

                    '</a>'

                    ) % {

                     'leadingspace': leadingspace,

                     '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

def changeset_status(repo, revision):

    from kallithea.model.changeset_status import ChangesetStatusModel

    return ChangesetStatusModel().get_status(repo, revision)

def changeset_status_lbl(changeset_status):

    from kallithea.model.db import ChangesetStatus

    return ChangesetStatus.get_status_lbl(changeset_status)

def get_permission_name(key):

    from kallithea.model.db import Permission

    return dict(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]

        Generate wildcards using '*' character:

            "repository:vcs*" - search everything starting with 'vcs'

            "repository:*vcs*" - search for repository containing 'vcs'

        Optional AND / OR operators in queries

            "repository:vcs OR repository:test"

            "username:test AND repository:test*"

    '''))

def not_mapped_error(repo_name):

    flash(_('%s repository is not mapped to db perhaps'

            ' it was created or renamed from the filesystem'

            ' please run the application again'

            ' in order to rescan repositories') % repo_name, category='error')

def ip_range(ip_addr):

    from kallithea.model.db import UserIpMap

    s, e = UserIpMap._get_ip_range(ip_addr)

    return '%s - %s' % (s, e)

def form(url, method="post", **attrs):

    """Like webhelpers.html.tags.form but automatically using secure_form with

    authentication_token for POST. authentication_token is thus never leaked

    in the URL."""

    if method.lower() == 'get':

        return insecure_form(url, method=method, **attrs)

    # webhelpers will turn everything but GET into POST

    return secure_form(url, method=method, **attrs)

        from kallithea.lib.helpers import gravatar_url

        _md5 = lambda s: hashlib.md5(s).hexdigest()

        # mock tg.tmpl_context

        def fake_tmpl_context(_url):

            _c = AttributeDict()

            _c.visual = AttributeDict()

            _c.visual.use_gravatar = True

            _c.visual.gravatar_url = _url

            return _c

        fake_url = FakeUrlGenerator(current_url='https://example.com')

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

            fake = fake_tmpl_context(_url='http://example.com/{email}')

            with mock.patch('tg.tmpl_context', fake):

                    from kallithea.config.routing import url

                    assert url.current() == 'https://example.com'

                    grav = gravatar_url(email_address='test@example.com', size=24)

                    assert grav == 'http://example.com/test@example.com'

            fake = fake_tmpl_context(_url='http://example.com/{email}')

            with mock.patch('tg.tmpl_context', fake):

                grav = gravatar_url(email_address='test@example.com', size=24)

                assert grav == 'http://example.com/test@example.com'

            fake = fake_tmpl_context(_url='http://example.com/{md5email}')

            with mock.patch('tg.tmpl_context', fake):

                em = 'test@example.com'

                grav = gravatar_url(email_address=em, size=24)

                assert grav == 'http://example.com/%s' % (_md5(em))

            fake = fake_tmpl_context(_url='http://example.com/{md5email}/{size}')

            with mock.patch('tg.tmpl_context', fake):

                em = 'test@example.com'

                grav = gravatar_url(email_address=em, size=24)

                assert grav == 'http://example.com/%s/%s' % (_md5(em), 24)

            fake = fake_tmpl_context(_url='{scheme}://{netloc}/{md5email}/{size}')

            with mock.patch('tg.tmpl_context', fake):

                em = 'test@example.com'

                grav = gravatar_url(email_address=em, size=24)

                assert grav == 'https://example.com/%s/%s' % (_md5(em), 24)

    @parametrize('tmpl,repo_name,overrides,prefix,expected', [

        (Repository.DEFAULT_CLONE_URI, 'group/repo1', {}, '', 'http://vps1:8000/group/repo1'),

        (Repository.DEFAULT_CLONE_URI, 'group/repo1', {'user': 'username'}, '', 'http://username@vps1:8000/group/repo1'),

        (Repository.DEFAULT_CLONE_URI, 'group/repo1', {}, '/prefix', 'http://vps1:8000/prefix/group/repo1'),

        (Repository.DEFAULT_CLONE_URI, 'group/repo1', {'user': 'user'}, '/prefix', 'http://user@vps1:8000/prefix/group/repo1'),

        (Repository.DEFAULT_CLONE_URI, 'group/repo1', {'user': 'username'}, '/prefix', 'http://username@vps1:8000/prefix/group/repo1'),

        (Repository.DEFAULT_CLONE_URI, 'group/repo1', {'user': 'user'}, '/prefix/', 'http://user@vps1:8000/prefix/group/repo1'),

        (Repository.DEFAULT_CLONE_URI, 'group/repo1', {'user': 'username'}, '/prefix/', 'http://username@vps1:8000/prefix/group/repo1'),

        ('{scheme}://{user}@{netloc}/_{repoid}', 'group/repo1', {}, '', 'http://vps1:8000/_23'),

        ('{scheme}://{user}@{netloc}/_{repoid}', 'group/repo1', {'user': 'username'}, '', 'http://username@vps1:8000/_23'),

        ('http://{user}@{netloc}/_{repoid}', 'group/repo1', {'user': 'username'}, '', 'http://username@vps1:8000/_23'),

        ('http://{netloc}/_{repoid}', 'group/repo1', {'user': 'username'}, '', 'http://vps1:8000/_23'),

        ('https://{user}@proxy1.example.com/{repo}', 'group/repo1', {'user': 'username'}, '', 'https://username@proxy1.example.com/group/repo1'),

        ('https://{user}@proxy1.example.com/{repo}', 'group/repo1', {}, '', 'https://proxy1.example.com/group/repo1'),

        ('https://proxy1.example.com/{user}/{repo}', 'group/repo1', {'user': 'username'}, '', 'https://proxy1.example.com/username/group/repo1'),

    ])

    def test_clone_url_generator(self, tmpl, repo_name, overrides, prefix, expected):

        from kallithea.lib.utils2 import get_clone_url

        clone_url = get_clone_url(uri_tmpl=tmpl, qualified_home_url='http://vps1:8000'+prefix,

                                  repo_name=repo_name, repo_id=23, **overrides)

        assert clone_url == expected

    def _quick_url(self, text, tmpl="""<a class="changeset_hash" href="%s">%s</a>""", url_=None):

        """

        Changes `some text url[foo]` => `some text <a href="/">foo</a>

        :param text:

        """

        import re

        # quickly change expected url[] into a link

        url_pattern = re.compile(r'(?:url\[)(.+?)(?:\])')

        def url_func(match_obj):

            _url = match_obj.groups()[0]

            return tmpl % (url_ or '/repo_name/changeset/%s' % _url, _url)

        return url_pattern.sub(url_func, text)

    @parametrize('sample,expected', [

      ("",

       ""),

      ("git-svn-id: https://svn.apache.org/repos/asf/libcloud/trunk@1441655 13f79535-47bb-0310-9956-ffa450edef68",

       """git-svn-id: <a href="https://svn.apache.org/repos/asf/libcloud/trunk@1441655">https://svn.apache.org/repos/asf/libcloud/trunk@1441655</a> 13f79535-47bb-0310-9956-ffa450edef68"""),

      ("from rev 000000000000",

       """from rev url[000000000000]"""),

      ("from rev 000000000000123123 also rev 000000000000",

       """from rev url[000000000000123123] also rev url[000000000000]"""),

      ("this should-000 00",

       """this should-000 00"""),

      ("longtextffffffffff rev 123123123123",

       """longtextffffffffff rev url[123123123123]"""),

      ("rev ffffffffffffffffffffffffffffffffffffffffffffffffff",

       """rev ffffffffffffffffffffffffffffffffffffffffffffffffff"""),

      ("ffffffffffff some text traalaa",

       """url[ffffffffffff] some text traalaa"""),

       ("""Multi line

       123123123123

       some text 123123123123

       sometimes !

       """,

       """Multi line<br/>"""

       """       url[123123123123]<br/>"""

       """       some text url[123123123123]<br/>"""

       """       sometimes !"""),

    ])

    def test_urlify_text(self, sample, expected):

        expected = self._quick_url(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') == expected

    @parametrize('sample,expected,url_', [

      ("",

       "",

       ""),

      ("https://svn.apache.org/repos",

       """url[https://svn.apache.org/repos]""",

       "https://svn.apache.org/repos"),

      ("http://svn.apache.org/repos",

       """url[http://svn.apache.org/repos]""",

       "http://svn.apache.org/repos"),

      ("from rev a also rev http://google.com",

       """from rev a also rev url[http://google.com]""",

       "http://google.com"),

      ("http://imgur.com/foo.gif inline http://imgur.com/foo.gif ending http://imgur.com/foo.gif",

       """url[http://imgur.com/foo.gif] inline url[http://imgur.com/foo.gif] ending url[http://imgur.com/foo.gif]""",

       "http://imgur.com/foo.gif"),

      ("""Multi line

       https://foo.bar.example.com

       some text lalala""",

       """Multi line<br/>"""

       """       url[https://foo.bar.example.com]<br/>"""

       """       some text lalala""",

       "https://foo.bar.example.com"),

      ("@mention @someone",

       """<b>@mention</b> <b>@someone</b>""",

       ""),

      ("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>.""",

       "-"),

      # 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', 'issue <a class="issue-tracker-link" href="http://foo/repo_name/issue/123">#123</a>'),

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

            'issue#456', 'issue<a class="issue-tracker-link" href="http://foo/repo_name/issue/456">#456</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}', '',

    ])

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

        from kallithea.lib.helpers import urlify_issues

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

            with mock.patch('kallithea.CONFIG', config_stub):

                assert urlify_issues(sample, 'repo_name') == expected

    @parametrize('sample,expected', [

        ('abc X5', 'abc <a class="issue-tracker-link" href="http://main/repo_name/main/5/">#5</a>'),

        ('abc pullrequest #6 xyz', 'abc <a class="issue-tracker-link" href="http://pr/repo_name/pr/6">PR#6</a> xyz'),

        ('pull request7 #', '<a class="issue-tracker-link" href="http://pr/repo_name/pr/7">PR#7</a> #'),

        ('look PR9 and pr #11', 'look <a class="issue-tracker-link" href="http://pr/repo_name/pr/9">PR#9</a> and <a class="issue-tracker-link" href="http://pr/repo_name/pr/11">PR#11</a>'),

        ('pullrequest#10 solves issue 9', '<a class="issue-tracker-link" href="http://pr/repo_name/pr/10">PR#10</a> solves <a class="issue-tracker-link" href="http://bug/repo_name/bug/9">bug#9</a>'),

        ('issue FAILMORE89', 'issue FAILMORE89'), # no match because absent prefix

    ])

    def test_urlify_issues_multiple_issue_patterns(self, sample, expected):

        from kallithea.lib.helpers import urlify_issues

        config_stub = {

            'sqlalchemy.url': 'foo',

            'issue_pat': 'X(\d+)',

            'issue_server_link': 'http://main/{repo}/main/{id}/',

            'issue_prefix': '#',

            'issue_pat_pr': '(?:pullrequest|pull request|PR|pr) ?#?(\d+)',

            'issue_server_link_pr': 'http://pr/{repo}/pr/{id}',

            'issue_prefix_pr': 'PR#',

            'issue_pat_bug': '(?:BUG|bug|issue) ?#?(\d+)',

            'issue_server_link_bug': 'http://bug/{repo}/bug/{id}',

            'issue_prefix_bug': 'bug#',

            'issue_pat_empty_prefix': 'FAIL(\d+)',

            'issue_server_link_empty_prefix': 'http://fail/{repo}/{id}',

            'issue_prefix_empty_prefix': '',

            'issue_pat_absent_prefix': 'FAILMORE(\d+)',

            'issue_server_link_absent_prefix': 'http://failmore/{repo}/{id}',

        }

        # force recreation of lazy function

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

            with mock.patch('kallithea.CONFIG', config_stub):

                assert urlify_issues(sample, 'repo_name') == expected

    @parametrize('test,expected', [

      ("", None),

      ("/_2", '2'),

      ("_2", '2'),

      ("/_2/", '2'),

      ("_2/", '2'),

      ("/_21", '21'),

      ("_21", '21'),

      ("/_21/", '21'),

      ("_21/", '21'),

      ("/_21/foobar", '21'),

      ("_21/121", '21'),

      ("/_21/_12", '21'),

      ("_21/prefix/foo", '21'),

    ])

    def test_get_repo_by_id(self, test, expected):

        from kallithea.lib.utils import _extract_id_from_repo_name

        _test = _extract_id_from_repo_name(test)

        assert _test == expected, 'url:%s, got:`%s` expected: `%s`' % (test, _test, expected)