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

        cgen('a', a_v, d_v), a_p, a_v

    )

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

        cgen('d', a_v, d_v), d_p, d_v

    )

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

def _urlify_text_replace(match_obj):

    url_full = match_obj.group(1)

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

def _urlify_text(s):

    """

    Extract urls from text and make html links out of them

    """

    return url_re.sub(_urlify_text_replace, s)

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

    """

    Extract urls from text and make literal html links out of them

    """

    if truncate is not None:

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

    s = html_escape(s)

    if stylize:

        s = desc_stylize(s)

    s = _urlify_text(s)

    return literal(s)

def _urlify_changeset_replace_f(repo_name):

    from pylons import url  # doh, we need to re-import url to mock it later

    def urlify_changeset_replace(match_obj):

        rev = match_obj.group(0)

        return '<a class="revision-link" href="%(url)s">%(rev)s</a>' % {

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

         'rev': rev,

        }

    return urlify_changeset_replace

urilify_changeset_re = r'(?:^|(?<=[\s(),]))([0-9a-fA-F]{12,40})(?=$|\s|[.,:()])'

def urlify_changesets(text_, repo_name):

    """

    Extract revision ids from changeset and make link from them

    """

    urlify_changeset_replace = _urlify_changeset_replace_f(repo_name)

    return re.sub(urilify_changeset_re, urlify_changeset_replace, text_)

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 not urls.match(e):

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

        else:

            links.append(e)

    return ''.join(links)

def urlify_commit(text_, repo_name, link_=None):

    """

    Parses given text message and makes proper links.

    Issues are linked to given issue-server. If link_ is provided, all other

    text will link there.

    """

    newtext = html_escape(text_)

    # urlify changesets - extract revisions and make link out of them

    newtext = urlify_changesets(newtext, repo_name)

    # extract http/https links and make them real urls

    newtext = _urlify_text(newtext)

    newtext = urlify_issues(newtext, repo_name, link_)

    return literal(newtext)

def _urlify_issues_replace_f(repo_name, ISSUE_SERVER_LNK, ISSUE_PREFIX):

    def urlify_issues_replace(match_obj):

        pref = ''

        if match_obj.group().startswith(' '):

            pref = ' '

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

        issue_url = ISSUE_SERVER_LNK.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 (

            '%(pref)s<a class="%(cls)s" href="%(url)s">'

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

            '</a>'

            ) % {

             'pref': pref,

             'cls': 'issue-tracker-link',

             'url': issue_url,

             'id-repr': issue_id,

             'issue-prefix': ISSUE_PREFIX,

             'serv': ISSUE_SERVER_LNK,

            }

    return urlify_issues_replace

def urlify_issues(newtext, repo_name, link_=None):

    from kallithea import CONFIG as conf

    # allow multiple issue servers to be used

    valid_indices = [

        x.group(1)

        for x in map(lambda x: re.match(r'issue_pat(.*)', x), conf.keys())

        if x and 'issue_server_link%s' % x.group(1) in conf

        and 'issue_prefix%s' % x.group(1) in conf

    ]

    if valid_indices:

        log.debug('found issue server suffixes `%s` during valuation of: %s',

                  ','.join(valid_indices), newtext)

    for pattern_index in valid_indices:

        ISSUE_PATTERN = conf.get('issue_pat%s' % pattern_index)

        ISSUE_SERVER_LNK = conf.get('issue_server_link%s' % pattern_index)

        ISSUE_PREFIX = conf.get('issue_prefix%s' % pattern_index)

        log.debug('pattern suffix `%s` PAT:%s SERVER_LINK:%s PREFIX:%s',

                  pattern_index, ISSUE_PATTERN, ISSUE_SERVER_LNK,

                  ISSUE_PREFIX)

        URL_PAT = re.compile(ISSUE_PATTERN)

        urlify_issues_replace = _urlify_issues_replace_f(repo_name, ISSUE_SERVER_LNK, ISSUE_PREFIX)

        newtext = URL_PAT.sub(urlify_issues_replace, newtext)

        log.debug('processed prefix:`%s` => %s', pattern_index, newtext)

    # if we actually did something above

    if link_:

        # wrap not links into final link => link_

        newtext = linkify_others(newtext, link_)

    return newtext

def _mentions_replace(match_obj):

    return '<b>@%s</b>' % match_obj.group(1)

def render_w_mentions(source, repo_name=None):

    """

    Render plain text with revision hashes and issue references urlified

    and with @mention highlighting.

    """

    s = source.rstrip()

    s = safe_unicode(s)

    s = '\n'.join(s.splitlines())

    s = html_escape(s)

    # this sequence of html-ifications seems to be safe and non-conflicting

    # if the issues regexp is sane

    s = _urlify_text(s)

    if repo_name is not None:

        s = urlify_changesets(s, repo_name)

    s = urlify_issues(s, repo_name)

    s = MENTIONS_REGEX.sub(_mentions_replace, s)

    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)