# -*- coding: utf-8 -*-

"""

    rhodecode.controllers.feed

    ~~~~~~~~~~~~~~~~~~~~~~~~~~

    Feed controller for rhodecode

    :created_on: Apr 23, 2010

    :author: marcink

    :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import logging

from pylons import url, response, tmpl_context as c

from pylons.i18n.translation import _

from beaker.cache import cache_region, region_invalidate

from webhelpers.feedgenerator import Atom1Feed, Rss201rev2Feed

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController

from rhodecode.lib.diffs import DiffProcessor, LimitedDiffContainer

from rhodecode.model.db import CacheInvalidation

from rhodecode.lib.utils2 import safe_int, str2bool, safe_unicode

log = logging.getLogger(__name__)

class FeedController(BaseRepoController):

    @LoginRequired(api_access=True)

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def __before__(self):

        super(FeedController, self).__before__()

        #common values for feeds

        self.description = _('Changes on %s repository')

        self.title = self.title = _('%s %s feed') % (c.rhodecode_name, '%s')

        self.language = 'en-us'

        self.ttl = "5"

        import rhodecode

        CONF = rhodecode.CONFIG

        self.include_diff = str2bool(CONF.get('rss_include_diff', False))

        self.feed_nr = safe_int(CONF.get('rss_items_per_page', 20))

        # we need to protect from parsing huge diffs here other way

        # we can kill the server

        self.feed_diff_limit = safe_int(CONF.get('rss_cut_off_limit', 32 * 1024))

    def _get_title(self, cs):

        return "%s" % (

            h.shorter(cs.message, 160)

        )

    def __changes(self, cs):

        changes = []

        diff_processor = DiffProcessor(cs.diff(),

                                       diff_limit=self.feed_diff_limit)

        _parsed = diff_processor.prepare(inline_diff=False)

        limited_diff = False

        if isinstance(_parsed, LimitedDiffContainer):

            limited_diff = True

        for st in _parsed:

            st.update({'added': st['stats']['added'],

                       'removed': st['stats']['deleted']})

            changes.append('\n %(operation)s %(filename)s '

                           '(%(added)s lines added, %(removed)s lines removed)'

                            % st)

        if limited_diff:

            changes = changes + ['\n ' +

                                 _('Changeset was too big and was cut off...')]

        return diff_processor, changes

    def __get_desc(self, cs):

        #branches, tags, bookmarks

        if cs.branch:

            desc_msg.append('branch: %s<br/>' % cs.branch)

        if h.is_hg(c.rhodecode_repo):

            for book in cs.bookmarks:

                desc_msg.append('bookmark: %s<br/>' % book)

        for tag in cs.tags:

            desc_msg.append('tag: %s<br/>' % tag)

        diff_processor, changes = self.__changes(cs)

        # rev link

        _url = url('changeset_home', repo_name=cs.repository.name,

                   revision=cs.raw_id, qualified=True)

        desc_msg.append('changeset: <a href="%s">%s</a>' % (_url, cs.raw_id[:8]))

        desc_msg.append('<pre>')

        desc_msg.append(cs.message)

        desc_msg.append('\n')

        desc_msg.extend(changes)

        if self.include_diff:

            desc_msg.append('\n\n')

            desc_msg.append(diff_processor.as_raw())

        desc_msg.append('</pre>')

        return map(safe_unicode, desc_msg)

    def atom(self, repo_name):

        """Produce an atom-1.0 feed via feedgenerator module"""

        @cache_region('long_term')

        def _get_feed_from_cache(key, kind):

            feed = Atom1Feed(

                 title=self.title % repo_name,

                 link=url('summary_home', repo_name=repo_name,

                          qualified=True),

                 description=self.description % repo_name,

                 language=self.language,

                 ttl=self.ttl

            )

            for cs in reversed(list(c.rhodecode_repo[-self.feed_nr:])):

                feed.add_item(title=self._get_title(cs),

                              link=url('changeset_home', repo_name=repo_name,

                                       revision=cs.raw_id, qualified=True),

                              author_name=cs.author,

                              description=''.join(self.__get_desc(cs)),

                              pubdate=cs.date,

                              )

            response.content_type = feed.mime_type

            return feed.writeString('utf-8')

        kind = 'ATOM'

        valid = CacheInvalidation.test_and_set_valid(repo_name, kind)

        if not valid:

            region_invalidate(_get_feed_from_cache, None, repo_name, kind)

        return _get_feed_from_cache(repo_name, kind)

    def rss(self, repo_name):

        """Produce an rss2 feed via feedgenerator module"""

        @cache_region('long_term')

        def _get_feed_from_cache(key, kind):

            feed = Rss201rev2Feed(

                title=self.title % repo_name,

                link=url('summary_home', repo_name=repo_name,

                         qualified=True),

                description=self.description % repo_name,

                language=self.language,

                ttl=self.ttl

            )

            for cs in reversed(list(c.rhodecode_repo[-self.feed_nr:])):

                feed.add_item(title=self._get_title(cs),

                              link=url('changeset_home', repo_name=repo_name,

                                       revision=cs.raw_id, qualified=True),

                              author_name=cs.author,

                              description=''.join(self.__get_desc(cs)),

                              pubdate=cs.date,

                             )

            response.content_type = feed.mime_type

            return feed.writeString('utf-8')

        kind = 'RSS'

        valid = CacheInvalidation.test_and_set_valid(repo_name, kind)

        if not valid:

            region_invalidate(_get_feed_from_cache, None, repo_name, kind)

        return _get_feed_from_cache(repo_name, kind)

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

def pygmentize(filenode, **kwargs):

    """

    pygmentize function using pygments

    :param filenode:

    """

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

    return literal(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 _ 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 = '%5s:%s' % ('r%s' % changeset.revision,

                                     short_id(changeset.raw_id))

            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(annotate_highlight(filenode, url_func(repo_name), **kwargs))

def is_following_repo(repo_name, user_id):

    from rhodecode.model.scm import ScmModel

    return ScmModel().is_following_repo(repo_name, user_id)

flash = _Flash()

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

# SCM FILTERS available via h.

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

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

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

from rhodecode.model.db import User, ChangesetStatus

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 rhodecode import CONFIG

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

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

    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:

        _fmt = _(u"%a, %d %b %Y %H:%M:%S").encode('utf8')

        return date.strftime(_fmt).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 email_or_none(author):

    # extract email from the commit string

    _email = email(author)

    if _email != '':

        # check it against RhodeCode database, and use the MAIN email for this

        # user

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

        if user is not None:

            return user.email

        return _email

    # See if it contains a username we can get an email from

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

                                cache=True)

    if user is not None:

        return user.email

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

    return None

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

    # attr to return from fetched user

    person_getter = lambda usr: getattr(usr, show_attr)

    # Valid email in the attribute passed, see if they're in the system

    _email = email(author)

    if _email != '':

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

        if user is not None:

            return person_getter(user)

    # Maybe it's a username?

    _author = author_name(author)

    user = User.get_by_username(_author, case_insensitive=True,

                                cache=True)

    if user is not None:

        return person_getter(user)

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

    return _author or _email

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

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

    """

    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('img', src=url("/images/icons/accept.png"),

                        alt=_('True'))

    else:

        return HTML.tag('img', src=url("/images/icons/cancel.png"),

                        alt=_('False'))

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)

        repo_name = user_log.repository.repo_name

        def lnk(rev, repo_name):

            if isinstance(rev, BaseChangeset) or isinstance(rev, AttributeDict):

                lazy_cs = True

                if getattr(rev, 'op', None) and getattr(rev, 'ref_name', None):

                    lazy_cs = False

                    lbl = '?'

                    if rev.op == 'delete_branch':

                        lbl = '%s' % _('Deleted branch: %s') % rev.ref_name

                        title = ''

                    elif rev.op == 'tag':

                        lbl = '%s' % _('Created tag: %s') % rev.ref_name

                        title = ''

                    _url = '#'

                else:

                    lbl = '%s' % (rev.short_id[:8])

                    _url = url('changeset_home', repo_name=repo_name,

                               revision=rev.raw_id)

                    title = tooltip(rev.message)

            else:

                ## changeset cannot be found/striped/removed etc.

                lbl = ('%s' % rev)[:12]

                _url = '#'

                title = _('Changeset not found')

            if parse_cs:

                return link_to(lbl, _url, title=title, class_='tooltip')

            return link_to(lbl, _url, raw_id=rev.raw_id, repo_name=repo_name,

                           class_='lazy-cs' if lazy_cs else '')

        def _get_op(rev_txt):

            _op = None

            _name = rev_txt

            if len(rev_txt.split('=>')) == 2:

                _op, _name = rev_txt.split('=>')

            return _op, _name

        revs = []

        if len(filter(lambda v: v != '', revs_ids)) > 0:

            repo = None

            for rev in revs_ids[:revs_top_limit]:

                _op, _name = _get_op(rev)

                # we want parsed changesets, or new log store format is bad

                if parse_cs:

                    try:

                        if repo is None:

                            repo = user_log.repository.scm_instance

                        _rev = repo.get_changeset(rev)

                        revs.append(_rev)

                    except ChangesetDoesNotExistError:

                        log.error('cannot find revision %s in this repo' % rev)

                        revs.append(rev)

                        continue

                else:

                    _rev = AttributeDict({

                        'short_id': rev[:12],

                        'raw_id': rev,

                        'message': '',

                        'op': _op,

                        'ref_name': _name

                    })

                    revs.append(_rev)

            [lnk(rev, repo_name) for rev in revs[:revs_limit]]

        _op1, _name1 = _get_op(revs_ids[0])

        _op2, _name2 = _get_op(revs_ids[-1])

        _rev = '%s...%s' % (_name1, _name2)

        compare_view = (

            ' <div class="compare_view tooltip" title="%s">'

            '<a href="%s">%s</a> </div>' % (

                _('Show all combined changesets %s->%s') % (

                    revs_ids[0][:12], revs_ids[-1][:12]

                ),

                url('changeset_home', repo_name=repo_name,

                    revision=_rev

                ),

                _('compare view')

            )

        )

        # if we have exactly one more than normally displayed

        # just display it, takes less space than displaying

        # "and 1 more revisions"

        if len(revs_ids) == revs_limit + 1:

            rev = revs[revs_limit]

            cs_links.append(", " + lnk(rev, repo_name))

        # hidden-by-default ones

        if len(revs_ids) > revs_limit + 1:

            uniq_id = revs_ids[0]

            html_tmpl = (

                '<span> %s <a class="show_more" id="_%s" '

                'href="#more">%s</a> %s</span>'

            )

            if not feed:

                cs_links.append(html_tmpl % (

                      _('and'),

                      uniq_id, _('%s more') % (len(revs_ids) - revs_limit),

                      _('revisions')

                    )

                )

            if not feed:

                html_tmpl = '<span id="%s" style="display:none">, %s </span>'

            else:

                html_tmpl = '<span id="%s"> %s </span>'

            morelinks = ', '.join(

              [lnk(rev, repo_name) for rev in revs[revs_limit:]]

            )

            if len(revs_ids) > revs_top_limit:

                morelinks += ', ...'

            cs_links.append(html_tmpl % (uniq_id, morelinks))

        if len(revs) > 1:

            cs_links.append(compare_view)

        return ''.join(cs_links)

    def get_fork_name():

        repo_name = action_params

        _url = url('summary_home', repo_name=repo_name)

        return _('fork name %s') % link_to(action_params, _url)

    def get_user_name():

        user_name = action_params

        return user_name

    def get_users_group():

        group_name = action_params

        return group_name

    def get_pull_request():

        pull_request_id = action_params

        deleted = user_log.repository is None

        if deleted:

            repo_name = user_log.repository_name

        else:

            repo_name = user_log.repository.repo_name

        return link_to(_('Pull request #%s') % pull_request_id,

                    url('pullrequest_show', repo_name=repo_name,

                    pull_request_id=pull_request_id))

    def get_archive_name():

        archive_name = action_params

        return archive_name

    # action : translated str, callback(extractor), icon

    action_map = {

    'user_deleted_repo':           (_('[deleted] repository'),

                                    None, 'database_delete.png'),

    'user_created_repo':           (_('[created] repository'),

                                    None, 'database_add.png'),

    'user_created_fork':           (_('[created] repository as fork'),

                                    None, 'arrow_divide.png'),

    'user_forked_repo':            (_('[forked] repository'),

                                    get_fork_name, 'arrow_divide.png'),

    'user_updated_repo':           (_('[updated] repository'),

                                    None, 'database_edit.png'),

    'user_downloaded_archive':      (_('[downloaded] archive from repository'),

                                    get_archive_name, 'page_white_compressed.png'),

    'admin_deleted_repo':          (_('[delete] repository'),

                                    None, 'database_delete.png'),

    'admin_created_repo':          (_('[created] repository'),

                                    None, 'database_add.png'),

    'admin_forked_repo':           (_('[forked] repository'),

                                    None, 'arrow_divide.png'),

    'admin_updated_repo':          (_('[updated] repository'),

                                    None, 'database_edit.png'),

    'admin_created_user':          (_('[created] user'),

                                    get_user_name, 'user_add.png'),

    'admin_updated_user':          (_('[updated] user'),

                                    get_user_name, 'user_edit.png'),

    'admin_created_users_group':   (_('[created] user group'),

                                    get_users_group, 'group_add.png'),

    'admin_updated_users_group':   (_('[updated] user group'),

                                    get_users_group, 'group_edit.png'),

    'user_commented_revision':     (_('[commented] on revision in repository'),

                                    get_cs_links, 'comment_add.png'),

    'user_commented_pull_request': (_('[commented] on pull request for'),

                                    get_pull_request, 'comment_add.png'),

    'user_closed_pull_request':    (_('[closed] pull request for'),

                                    get_pull_request, 'tick.png'),

    'push':                        (_('[pushed] into'),

                                    get_cs_links, 'script_add.png'),

    'push_local':                  (_('[committed via RhodeCode] into repository'),

                                    get_cs_links, 'script_edit.png'),

    'push_remote':                 (_('[pulled from remote] into repository'),

                                    get_cs_links, 'connect.png'),

    'pull':                        (_('[pulled] from'),

                                    None, 'down_16.png'),

    'started_following_repo':      (_('[started following] repository'),

                                    None, 'heart_add.png'),

    'stopped_following_repo':      (_('[stopped following] repository'),

                                    None, 'heart_delete.png'),

    }

    action_str = action_map.get(action, action)

    if feed:

        action = action_str[0].replace('[', '').replace(']', '')

    else:

        action = action_str[0]\

            .replace('[', '<span class="journal_highlight">')\

            .replace(']', '</span>')

    action_params_func = lambda: ""

    if callable(action_str[1]):

        action_params_func = action_str[1]

    def action_parser_icon():

        action = user_log.action

        action_params = None

        x = action.split(':')

        if len(x) > 1:

            action, action_params = x

        tmpl = """<img src="%s%s" alt="%s"/>"""

        ico = action_map.get(action, ['', '', ''])[2]

        return literal(tmpl % ((url('/images/icons/')), ico, action))

    # returned callbacks we need to call to get

    return [lambda: literal(action), action_params_func, action_parser_icon]

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

# PERMS

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

from rhodecode.lib.auth import HasPermissionAny, HasPermissionAll, \

HasRepoPermissionAny, HasRepoPermissionAll, HasReposGroupPermissionAll, \

HasReposGroupPermissionAny

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

# GRAVATAR URL

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

def gravatar_url(email_address, size=30):

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

    _def = 'anonymous@rhodecode.org'

    use_gravatar = str2bool(config['app_conf'].get('use_gravatar'))

    email_address = email_address or _def

    if (not use_gravatar or not email_address or email_address == _def):

        f = lambda a, l: min(l, key=lambda x: abs(x - a))

        return url("/images/user%s.png" % f(size, [14, 16, 20, 24, 30]))

    if use_gravatar and config['app_conf'].get('alternative_gravatar_url'):

        tmpl = config['app_conf'].get('alternative_gravatar_url', '')

        parsed_url = urlparse.urlparse(url.current(qualified=True))

        tmpl = tmpl.replace('{email}', email_address)\

                   .replace('{md5email}', hashlib.md5(email_address.lower()).hexdigest()) \

                   .replace('{netloc}', parsed_url.netloc)\

                   .replace('{scheme}', parsed_url.scheme)\

                   .replace('{size}', str(size))

        return tmpl

    ssl_enabled = 'https' == request.environ.get('wsgi.url_scheme')

    default = 'identicon'

    baseurl_nossl = "http://www.gravatar.com/avatar/"

    baseurl_ssl = "https://secure.gravatar.com/avatar/"

    baseurl = baseurl_ssl if ssl_enabled else baseurl_nossl

    if isinstance(email_address, unicode):

        #hashlib crashes on unicode items

        email_address = safe_str(email_address)

    # construct the url

    gravatar_url = baseurl + hashlib.md5(email_address.lower()).hexdigest() + "?"

    gravatar_url += urllib.urlencode({'d': default, 's': str(size)})

    return gravatar_url

class Page(_Page):

    """

    Custom pager to match rendering style with YUI paginator

    """

    def _get_pos(self, cur_page, max_page, items):

        edge = (items / 2) + 1

        if (cur_page <= edge):

            radius = max(items / 2, items - cur_page)

        elif (max_page - cur_page) < edge:

            radius = (items - 1) - (max_page - cur_page)

        else:

            radius = items / 2

        left = max(1, (cur_page - (radius)))

        right = min(max_page, cur_page + (radius))

        return left, cur_page, right

    def _range(self, regexp_match):

        """

        Return range of linked pages (e.g. '1 2 [3] 4 5 6 7 8').

        Arguments:

        regexp_match

            A "re" (regular expressions) match object containing the

            radius of linked pages around the current page in

            regexp_match.group(1) as a string

        This function is supposed to be called as a callable in

        re.sub.

        """

        radius = int(regexp_match.group(1))

        # Compute the first and last page number within the radius

        # e.g. '1 .. 5 6 [7] 8 9 .. 12'

        # -> leftmost_page  = 5

        # -> rightmost_page = 9

        leftmost_page, _cur, rightmost_page = self._get_pos(self.page,

                                                            self.last_page,

                                                            (radius * 2) + 1)

        nav_items = []

        # Create a link to the first page (unless we are on the first page

        # or there would be no need to insert '..' spacers)

        if self.page != self.first_page and self.first_page < leftmost_page:

            nav_items.append(self._pagerlink(self.first_page, self.first_page))

        # Insert dots if there are pages between the first page

        # and the currently displayed page range

        if leftmost_page - self.first_page > 1:

            # Wrap in a SPAN tag if nolink_attr is set

            text = '..'

            if self.dotdot_attr:

                text = HTML.span(c=text, **self.dotdot_attr)

            nav_items.append(text)

        for thispage in xrange(leftmost_page, rightmost_page + 1):

            # Hilight the current page number and do not use a link

            if thispage == self.page:

                text = '%s' % (thispage,)

                # Wrap in a SPAN tag if nolink_attr is set

                if self.curpage_attr:

                    text = HTML.span(c=text, **self.curpage_attr)

                nav_items.append(text)

            # Otherwise create just a link to that page

            else:

                text = '%s' % (thispage,)

                nav_items.append(self._pagerlink(thispage, text))

        # Insert dots if there are pages between the displayed

        # page numbers and the end of the page range

        if self.last_page - rightmost_page > 1:

            text = '..'

            # Wrap in a SPAN tag if nolink_attr is set

            if self.dotdot_attr:

                text = HTML.span(c=text, **self.dotdot_attr)

            nav_items.append(text)

        # Create a link to the very last page (unless we are on the last

        # page or there would be no need to insert '..' spacers)

        if self.page != self.last_page and rightmost_page < self.last_page:

            nav_items.append(self._pagerlink(self.last_page, self.last_page))

        return self.separator.join(nav_items)