if l_type == 'd' and not a_v:

            return ' '.join(map(map_getter, ['tr', 'br', 'tl', 'bl']))

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

            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 %s" style="width:100%%">%s</div>' % (bin_op, cgen('a', a_v='', d_v=0), lbl)

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

        return literal('<div style="width:%spx">%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 %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,

        }

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

    """

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