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

    """

    url_pat = re.compile(r'''(http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]'''

                         '''|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+)''')

    def url_func(match_obj):

        url_full = match_obj.groups()[0]

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

    _newtext = url_pat.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

    URL_PAT = re.compile(r'(^|\s)([0-9a-fA-F]{12,40})($|\s)')

    def url_func(match_obj):

        rev = match_obj.groups()[1]

        pref = match_obj.groups()[0]

        suf = match_obj.groups()[2]

        tmpl = (

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

        '%(rev)s</a>%(suf)s'

        )

        return tmpl % {

         'pref': pref,

         'cls': 'revision-link',

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

         'rev': rev,

         'suf': suf

        }

    newtext = URL_PAT.sub(url_func, text_)

    return newtext

def urlify_commit(text_, repository=None, 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

    """

    import traceback

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

    def escaper(string):

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

    def linkify_others(t, l):

        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)

    # urlify changesets - extrac 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())

                tmpl = (

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

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

                '</a>'

                )

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

                if repository:

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

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

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

                return tmpl % {

                     'pref': pref,

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

                     'url': 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

    return literal(newtext)

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

def journal_filter_help():

    return _(textwrap.dedent('''

        Example filter terms:

            repository:vcs

            action:*push*

            ip:127.0.0.1

            date:20120101

            date:[20120101100000 TO 20120102]

        Generate wildcards using '*' character:

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