fl = self.linenostart

        mw = len(str(lncount + fl - 1))

        sp = self.linenospecial

        st = self.linenostep

        la = self.lineanchors

        aln = self.anchorlinenos

        nocls = self.noclasses

        if sp:

            lines = []

            for i in range(fl, fl + lncount):

                if i % st == 0:

                    if i % sp == 0:

                        if aln:

                            lines.append('<a href="#%s%d" class="special">%*d</a>' %

                                         (la, i, mw, i))

                        else:

                            lines.append('<span class="special">%*d</span>' % (mw, i))

                    else:

                        if aln:

                            lines.append('<a href="#%s%d">%*d</a>' % (la, i, mw, i))

                        else:

                            lines.append('%*d' % (mw, i))

                else:

                    lines.append('')

            ls = '\n'.join(lines)

        else:

            lines = []

            for i in range(fl, fl + lncount):

                if i % st == 0:

                    if aln:

                        lines.append('<a href="#%s%d">%*d</a>' % (la, i, mw, i))

                    else:

                        lines.append('%*d' % (mw, i))

                else:

                    lines.append('')

            ls = '\n'.join(lines)

        # in case you wonder about the seemingly redundant <div> here: since the

        # content in the other cell also is wrapped in a div, some browsers in

        # some configurations seem to mess up the formatting...

        if nocls:

            yield 0, ('<table class="%stable">' % self.cssclass +

                      '<tr><td><div class="linenodiv" '

                      'style="background-color: #f0f0f0; padding-right: 10px">'

                      '<pre style="line-height: 125%">' +

                      ls + '</pre></div></td><td id="hlcode" class="code">')

        else:

            yield 0, ('<table class="%stable">' % self.cssclass +

                      '<tr><td class="linenos"><div class="linenodiv"><pre>' +

                      ls + '</pre></div></td><td id="hlcode" class="code">')

        yield 0, dummyoutfile.getvalue()

        yield 0, '</td></tr></table>'

_whitespace_re = re.compile(r'(\t)|( )(?=\n|</div>)')

def _markup_whitespace(m):

    groups = m.groups()

    if groups[0]:

        return '<u>\t</u>'

    if groups[1]:

        return ' <i></i>'

def markup_whitespace(s):

    return _whitespace_re.sub(_markup_whitespace, s)

def pygmentize(filenode, **kwargs):

    """

    pygmentize function using pygments

    :param filenode:

    """

    lexer = get_custom_lexer(filenode.extension) or filenode.lexer

    return literal(markup_whitespace(

        code_highlight(filenode.content, lexer, CodeHtmlFormatter(**kwargs))))

def pygmentize_annotation(repo_name, filenode, **kwargs):

    """

    pygmentize function for annotation

    :param filenode:

    """

    color_dict = {}

    def gen_color(n=10000):

        """generator for getting n of evenly distributed colors using

        hsv color and golden ratio. It always return same order of colors

        :returns: RGB tuple

        """

        def hsv_to_rgb(h, s, v):

            if s == 0.0:

                return v, v, v

            i = int(h * 6.0)  # XXX assume int() truncates!

            f = (h * 6.0) - i

            p = v * (1.0 - s)

            q = v * (1.0 - s * f)

            t = v * (1.0 - s * (1.0 - f))

            i = i % 6

            if i == 0:

                return v, t, p

            if i == 1:

                return q, v, p

            if i == 2:

                return p, v, t

            if i == 3:

                return p, q, v

            if i == 4:

                return t, p, v

            if i == 5:

                return v, p, q

        golden_ratio = 0.618033988749895

        h = 0.22717784590367374

        for _unused in xrange(n):

            h += golden_ratio

            h %= 1

            HSV_tuple = [h, 0.95, 0.95]

            RGB_tuple = hsv_to_rgb(*HSV_tuple)

            yield map(lambda x: str(int(x * 256)), RGB_tuple)

    cgenerator = gen_color()

    def get_color_string(cs):

        if cs in color_dict:

            col = color_dict[cs]

        else:

            col = color_dict[cs] = cgenerator.next()

        return "color: rgb(%s)! important;" % (', '.join(col))

    def url_func(repo_name):

        def _url_func(changeset):

            author = changeset.author

            date = changeset.date

            message = tooltip(changeset.message)

            tooltip_html = ("<div style='font-size:0.8em'><b>Author:</b>"

                            " %s<br/><b>Date:</b> %s</b><br/><b>Message:"

                            "</b> %s<br/></div>")

            tooltip_html = tooltip_html % (author, date, message)

            lnk_format = show_id(changeset)

            uri = link_to(

                    lnk_format,

                    url('changeset_home', repo_name=repo_name,

                        revision=changeset.raw_id),

                    style=get_color_string(changeset.raw_id),

                    class_='tooltip',

                    title=tooltip_html

                  )

            uri += '\n'

            return uri

        return _url_func

    return literal(markup_whitespace(annotate_highlight(filenode, url_func(repo_name), **kwargs)))

def is_following_repo(repo_name, user_id):

    from kallithea.model.scm import ScmModel

    return ScmModel().is_following_repo(repo_name, user_id)

class _Message(object):

    """A message returned by ``Flash.pop_messages()``.

    Converting the message to a string returns the message text. Instances

    also have the following attributes:

    * ``message``: the message text.

    * ``category``: the category specified when the message was created.

    """

    def __init__(self, category, message):

        self.category = category

        self.message = message

    def __str__(self):

        return self.message

    __unicode__ = __str__

    def __html__(self):

        return escape(safe_unicode(self.message))

class Flash(_Flash):

    def pop_messages(self):

        """Return all accumulated messages and delete them from the session.

        The return value is a list of ``Message`` objects.

        """

        from pylons import session

        messages = session.pop(self.session_key, [])

        session.save()

        return [_Message(*m) for m in messages]

flash = Flash()

#==============================================================================

# SCM FILTERS available via h.

#==============================================================================

from kallithea.lib.vcs.utils import author_name, author_email

from kallithea.lib.utils2 import credentials_filter, age as _age

from kallithea.model.db import User, ChangesetStatus, PullRequest

age = lambda  x, y=False: _age(x, y)

capitalize = lambda x: x.capitalize()

email = author_email

short_id = lambda x: x[:12]

hide_credentials = lambda x: ''.join(credentials_filter(x))

def show_id(cs):

    """

    Configurable function that shows ID

    by default it's r123:fffeeefffeee

    :param cs: changeset instance

    """

    from kallithea import CONFIG

    def_len = safe_int(CONFIG.get('show_sha_length', 12))

    show_rev = str2bool(CONFIG.get('show_revision_number', False))

    raw_id = cs.raw_id[:def_len]

    if show_rev:

        return 'r%s:%s' % (cs.revision, raw_id)

    else:

        return '%s' % (raw_id)

def fmt_date(date):

    if date:

        return date.strftime("%Y-%m-%d %H:%M:%S").decode('utf8')

    return ""

def is_git(repository):

    if hasattr(repository, 'alias'):

        _type = repository.alias

    elif hasattr(repository, 'repo_type'):

        _type = repository.repo_type

    else:

        _type = repository

    return _type == 'git'

def is_hg(repository):

    if hasattr(repository, 'alias'):

        _type = repository.alias

    elif hasattr(repository, 'repo_type'):

        _type = repository.repo_type

    else:

        _type = repository

    return _type == 'hg'

def user_or_none(author):

    email = author_email(author)

    if email:

        user = User.get_by_email(email, case_insensitive=True, cache=True)

        if user is not None:

            return user

    user = User.get_by_username(author_name(author), case_insensitive=True, cache=True)

    if user is not None:

        return user

    return None

def email_or_none(author):

    if not author:

        return None

    user = user_or_none(author)

    if user is not None:

        return user.email # always use main email address - not necessarily the one used to find user

    # extract email from the commit string

    email = author_email(author)

    if email:

        return email

    # No valid email, not a valid user in the system, none!

    return None

def person(author, show_attr="username"):

    """Find the user identified by 'author', return one of the users attributes,

    default to the username attribute, None if there is no user"""

    # attr to return from fetched user

    person_getter = lambda usr: getattr(usr, show_attr)

    # if author is already an instance use it for extraction

    if isinstance(author, User):

        return person_getter(author)

    user = user_or_none(author)

    if user is not None:

        return person_getter(user)

    # Still nothing?  Just pass back the author name if any, else the email

    return author_name(author) or email(author)

def person_by_id(id_, show_attr="username"):

    # attr to return from fetched user

    person_getter = lambda usr: getattr(usr, show_attr)

    #maybe it's an ID ?

    if str(id_).isdigit() or isinstance(id_, int):

        id_ = int(id_)

        user = User.get(id_)

        if user is not None:

            return person_getter(user)

    return id_

def desc_stylize(value):

    """

    converts tags from value into html equivalent

    :param value:

    """

    if not value:

        return ''

    value = re.sub(r'\[see\ \=>\ *([a-zA-Z0-9\/\=\?\&\ \:\/\.\-]*)\]',

                   '<div class="metatag" tag="see">see =&gt; \\1 </div>', value)

    value = re.sub(r'\[license\ \=>\ *([a-zA-Z0-9\/\=\?\&\ \:\/\.\-]*)\]',

                   '<div class="metatag" tag="license"><a href="http:\/\/www.opensource.org/licenses/\\1">\\1</a></div>', value)

    value = re.sub(r'\[(requires|recommends|conflicts|base)\ \=>\ *([a-zA-Z0-9\-\/]*)\]',

                   '<div class="metatag" tag="\\1">\\1 =&gt; <a href="/\\2">\\2</a></div>', value)

    value = re.sub(r'\[(lang|language)\ \=>\ *([a-zA-Z\-\/\#\+]*)\]',

                   '<div class="metatag" tag="lang">\\2</div>', value)

    value = re.sub(r'\[([a-z]+)\]',

                  '<div class="metatag" tag="\\1">\\1</div>', value)

    return value

def boolicon(value):

    """Returns boolean value of a value, represented as small html image of true/false

    icons

    :param value: value

    """

    if value:

        return HTML.tag('i', class_="icon-ok")

    else:

        return HTML.tag('i', class_="icon-minus-circled")

def action_parser(user_log, feed=False, parse_cs=False):

    """

    This helper will action_map the specified string action into translated

    fancy names with icons and links

    :param user_log: user log instance

    :param feed: use output for feeds (no html and fancy icons)

    :param parse_cs: parse Changesets into VCS instances

    """

    action = user_log.action

    action_params = ' '

    x = action.split(':')

    if len(x) > 1:

        action, action_params = x

    def get_cs_links():

        revs_limit = 3  # display this amount always

        revs_top_limit = 50  # show upto this amount of changesets hidden

        revs_ids = action_params.split(',')

        deleted = user_log.repository is None

        if deleted:

            return ','.join(revs_ids)