assert k.startswith('div_'), k

        attributes.append(' %s="%s"' % (k[4:].replace('_', '-'), escape(v)))

    return literal("""<span%s>%s</span>""" %

                   (''.join(attributes),

                    gravatar(email_address, cls=cls, size=size)))

def gravatar(email_address, cls='', size=30):

    """return html element of the gravatar

    This method will return an <img> with the resolution double the size (for

    retina screens) of the image. If the url returned from gravatar_url is

    empty then we fallback to using an icon.

    """

    from tg import tmpl_context as c

    if not c.visual.use_gravatar:

        return ''

    src = gravatar_url(email_address, size * 2)

    if src:

        # here it makes sense to use style="width: ..." (instead of, say, a

        # stylesheet) because we using this to generate a high-res (retina) size

        html = ('<i class="icon-gravatar {cls}"'

                ' style="font-size: {size}px;background-size: {size}px;background-image: url(\'{src}\')"'

                '></i>').format(cls=cls, size=size, src=src)

    else:

        # if src is empty then there was no gravatar, so we use a font icon

        html = ("""<i class="icon-user {cls}" style="font-size: {size}px;"></i>"""

            .format(cls=cls, size=size))

    return literal(html)

def gravatar_url(email_address, size=30, default=''):

    from tg import tmpl_context as c

    if not c.visual.use_gravatar:

        return ""

    _def = 'anonymous@kallithea-scm.org'  # default gravatar

    email_address = email_address or _def

    if email_address == _def:

        return default

    from kallithea.model.db import User

    parsed_url = urllib.parse.urlparse(url.current(qualified=True))

               .replace('{email}', email_address) \

               .replace('{md5email}', hashlib.md5(safe_bytes(email_address).lower()).hexdigest()) \

               .replace('{netloc}', parsed_url.netloc) \

               .replace('{scheme}', parsed_url.scheme) \

               .replace('{size}', str(size))

def changed_tooltip(nodes):

    """

    Generates a html string for changed nodes in changeset page.

    It limits the output to 30 entries

    :param nodes: LazyNodesGenerator

    """

    if nodes:

        pref = ': <br/> '

        suf = ''

        if len(nodes) > 30:

            suf = '<br/>' + _(' and %s more') % (len(nodes) - 30)

        return literal(pref + '<br/> '.join([x.path

                                             for x in nodes[:30]]) + suf)

    else:

        return ': ' + _('No files')

def fancy_file_stats(stats):

    """

    Displays a fancy two colored bar for number of added/deleted

    lines of code on file

    :param stats: two element list of added/deleted lines of code

    """

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

    a, d = stats['added'], stats['deleted']

    width = 100

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

    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.

    >>> urlify_text("Urlify http://example.com/ and 'https://example.com' *and* <b>markup/b>")

    literal('Urlify <a href="http://example.com/">http://example.com/</a> and &#39;<a href="https://example.com&apos">https://example.com&apos</a>; <b>*and*</b> &lt;b&gt;markup/b&gt;')

    """

    def _replace(match_obj):

        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:

            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/>')

    # Turn HTML5 into more valid HTML4 as required by some mail readers.

    # (This is not done in one step in html_escape, because character codes like

    # { risk to be seen as an issue reference due to the presence of '#'.)

    s = s.replace("'", "'")

"""

import datetime

import hashlib

import mock

from tg.util.webtest import test_context

from kallithea.lib.utils2 import AttributeDict, safe_bytes

from kallithea.model.db import Repository

from kallithea.tests import base

proto = 'http'

TEST_URLS = [

    ('%s://127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],

     '%s://127.0.0.1' % proto),

    ('%s://username@127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],

     '%s://127.0.0.1' % proto),

    ('%s://username:pass@127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],

     '%s://127.0.0.1' % proto),

    ('%s://127.0.0.1:8080' % proto, ['%s://' % proto, '127.0.0.1', '8080'],

     '%s://127.0.0.1:8080' % proto),

    ('%s://example.com' % proto, ['%s://' % proto, 'example.com'],

     '%s://example.com' % proto),

    ('%s://user:pass@example.com:8080' % proto, ['%s://' % proto, 'example.com',

                                                '8080'],

     '%s://example.com:8080' % proto),

]

proto = 'https'

TEST_URLS += [

    ('%s://127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],

     '%s://127.0.0.1' % proto),

    ('%s://username@127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],

     '%s://127.0.0.1' % proto),

    ('%s://username:pass@127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],

     '%s://127.0.0.1' % proto),

    ('%s://127.0.0.1:8080' % proto, ['%s://' % proto, '127.0.0.1', '8080'],

     '%s://127.0.0.1:8080' % proto),

    ('%s://example.com' % proto, ['%s://' % proto, 'example.com'],

     '%s://example.com' % proto),

    ('%s://user:pass@example.com:8080' % proto, ['%s://' % proto, 'example.com',

                                                '8080'],

     '%s://example.com:8080' % proto),

]

class TestLibs(base.TestController):

    @base.parametrize('test_url,expected,expected_creds', TEST_URLS)

    def test_uri_filter(self, test_url, expected, expected_creds):

        from kallithea.lib.utils2 import uri_filter

        assert uri_filter(test_url) == expected

    @base.parametrize('test_url,expected,expected_creds', TEST_URLS)

    def test_credentials_filter(self, test_url, expected, expected_creds):

        from kallithea.lib.utils2 import credentials_filter

        assert credentials_filter(test_url) == expected_creds

    @base.parametrize('str_bool,expected', [

                           ('t', True),

                           ('true', True),

                           ('y', True),

                           ('yes', True),

                           ('on', True),

                           ('1', True),

                           ('Y', True),

                           ('yeS', True),

                           ('Y', True),

                           ('TRUE', True),

                           ('T', True),

                           ('False', False),

                           ('F', False),

                           ('FALSE', False),

                           ('0', False),

    ])

    def test_asbool(self, str_bool, expected):

        from kallithea.lib.utils2 import asbool

        assert asbool(str_bool) == expected

    def test_mention_extractor(self):

        from kallithea.lib.utils2 import extract_mentioned_usernames

        sample = (

            "@first hi there @world here's my email username@example.com "

            "@lukaszb check @one_more22 it pls @ ttwelve @D[] @one@two@three "

            "@UPPER    @cAmEL @2one_more22 @john please see this http://org.pl "

            "@marian.user just do it @marco-polo and next extract @marco_polo "

            "user.dot  hej ! not-needed maril@example.com"

        )

        expected = set([

            '2one_more22', 'first', 'lukaszb', 'one', 'one_more22', 'UPPER', 'cAmEL', 'john',

            'marian.user', 'marco-polo', 'marco_polo', 'world'])

        assert expected == set(extract_mentioned_usernames(sample))

        (dict(), 'just now'),

        (dict(seconds=1), 'in 1 second'),

        (dict(seconds=60 * 2), 'in 2 minutes'),

        (dict(hours=1), 'in 1 hour'),

        (dict(hours=24), 'in 1 day'),

        (dict(hours=24 * 5), 'in 5 days'),

        (dict(months=1), 'in 1 month'),

        (dict(months=1, days=1), 'in 1 month and 1 day'),

        (dict(years=1, months=1), 'in 1 year and 1 month')

    ])

    def test_age_in_future(self, age_args, expected):

        from dateutil import relativedelta

        from kallithea.lib.utils2 import age

        with test_context(self.app):

            n = datetime.datetime(year=2012, month=5, day=17)

            delt = lambda *args, **kwargs: relativedelta.relativedelta(*args, **kwargs)

            assert age(n + delt(**age_args), now=n) == expected

    def test_tag_extractor(self):

        sample = (

            "hello pta[tag] gog [[]] [[] sda ero[or]d [me =>>< sa]"

            "[requires] [stale] [see<>=>] [see => http://example.com]"

            "[requires => url] [lang => python] [just a tag]"

            "[,d] [ => ULR ] [obsolete] [desc]]"

        )

        from kallithea.lib.helpers import urlify_text

        res = urlify_text(sample, stylize=True)

        assert '<div class="label label-meta" data-tag="tag">tag</div>' in res

        assert '<div class="label label-meta" data-tag="obsolete">obsolete</div>' in res

        assert '<div class="label label-meta" data-tag="stale">stale</div>' in res

        assert '<div class="label label-meta" data-tag="lang">python</div>' in res

        assert '<div class="label label-meta" data-tag="requires">requires =&gt; <a href="/url">url</a></div>' in res

        assert '<div class="label label-meta" data-tag="tag">tag</div>' in res

    def test_alternative_gravatar(self):

        from kallithea.lib.helpers import gravatar_url

        _md5 = lambda s: hashlib.md5(safe_bytes(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 = 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)

    @base.parametrize('clone_uri_tmpl,repo_name,username,prefix,expected', [

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    ])

    def test_clone_url_generator(self, clone_uri_tmpl, repo_name, username, prefix, expected):

        from kallithea.lib.utils2 import get_clone_url

                                  repo_name=repo_name, repo_id=23, username=username)

        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)

    @base.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)

            from kallithea.lib.helpers import urlify_text

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

    @base.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>.""",

       "-"),

      ("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_)

            from kallithea.lib.helpers import urlify_text

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

    @base.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):

            from kallithea.lib.helpers import urlify_text

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

    @base.parametrize('issue_pat,issue_server,issue_sub,sample,expected', [

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

            '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/\\1', '#\\1',

            '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>"""),

        # to require whitespace before the issue reference, one may be tempted to use \b...

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

            'issue PR123 and issuePR456',

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

            """issuePR456"""),

        # ... but it turns out that \b does not work well in combination with '#': the expectations

        # are reversed from what is actually happening.

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

            'issue #123 and issue#456',

            """issue #123 and """

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

        # ... so maybe try to be explicit? Unfortunately the whitespace before the issue

        # reference is not retained, again, because it is part of the pattern.

        (r'(?:^|\s)#(\d+)', 'http://foo/{repo}/issue/\\1', '#\\1',

            '#15 and issue #123 and issue#456',

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

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

            """issue#456"""),

        # ... instead, use lookbehind assertions.

        (r'(?:^|(?<=\s))#(\d+)', 'http://foo/{repo}/issue/\\1', '#\\1',

            '#15 and issue #123 and issue#456',

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

            """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/\\1', 'PR#\\1',

            '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/\\1', 'PR\\1',

            '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}/\\1', '\\1',

            '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/\\1">BUG12345</a>."""),