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 %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(text_, safe=True):

    """

    Extrac urls from text and make html links out of them

    :param text_:

    """

    def url_func(match_obj):

        url_full = match_obj.groups()[0]

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

    _newtext = url_re.sub(url_func, text_)

    if safe:

        return literal(_newtext)

    return _newtext

def urlify_changesets(text_, repository):

    """

    Extract revision ids from changeset and make link from them

    :param text_:

    :param repository: repo name to build the URL with

    """

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

    def url_func(match_obj):

        rev = match_obj.group(0)

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

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

         'rev': rev,

        }

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

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

    """

    Parses given text message and makes proper links.

    issues are linked to given issue-server, and rest is a changeset link

    if link_ is given, in other case it's a plain text

    :param text_:

    :param repository:

    :param link_: changeset link

    """

    def escaper(string):

        return string.replace('<', '&lt;').replace('>', '&gt;')

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

    newtext = urlify_changesets(escaper(text_), repository)

    # extract http/https links and make them real urls

    newtext = urlify_text(newtext, safe=False)

    try:

        from kallithea import CONFIG

        conf = CONFIG

        # 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

        ]

        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(r'%s' % ISSUE_PATTERN)

            def url_func(match_obj):

                pref = ''

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

                    pref = ' '

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

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

                if repository:

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

                    repo_name = repository.split(URL_SEP)[-1]

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

                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,

                    }

            newtext = URL_PAT.sub(url_func, 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_)

    except Exception:

        log.error(traceback.format_exc())

        pass

def rst(source):

    return literal('<div class="rst-block">%s</div>' %

                   MarkupRenderer.rst(source))

def rst_w_mentions(source):

    """

    Wrapped rst renderer with @mention highlighting

    :param source:

    """

    return literal('<div class="rst-block">%s</div>' %

                   MarkupRenderer.rst_with_mentions(source))

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

    return ChangesetStatusModel().get_status(repo, revision)

def changeset_status_lbl(changeset_status):

    return dict(ChangesetStatus.STATUSES).get(changeset_status)

def get_permission_name(key):

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