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

"""

    rhodecode.controllers.changelog

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

    changelog controller for rhodecode

    :created_on: Apr 21, 2010

    :author: marcink

    :copyright: (C) 2009-2011 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 mercurial import graphmod

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.helpers import RepoPage

from rhodecode.lib.compat import json

log = logging.getLogger(__name__)

class ChangelogController(BaseRepoController):

    @LoginRequired()

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

                                   'repository.admin')

    def __before__(self):

        super(ChangelogController, self).__before__()

        c.affected_files_cut_off = 60

    def index(self):

        limit = 100

        default = 20

        if request.params.get('size'):

            try:

                int_size = int(request.params.get('size'))

            except ValueError:

                int_size = default

            int_size = int_size if int_size <= limit else limit

            c.size = int_size

            session['changelog_size'] = c.size

            session.save()

        else:

            c.size = int(session.get('changelog_size', default))

        p = int(request.params.get('page', 1))

        branch_name = request.params.get('branch', None)

        c.total_cs = len(c.rhodecode_repo)

        return render('changelog/changelog.html')

    def changelog_details(self, cs):

        if request.environ.get('HTTP_X_PARTIAL_XHR'):

            c.cs = c.rhodecode_repo.get_changeset(cs)

            return render('changelog/changelog_details.html')

        """

        Generates a DAG graph for mercurial

        :param repo: repo instance

        :param size: number of commits to show

        :param p: page number

        """

            c.jsdata = json.dumps([])

            return

        revcount = min(repo_size, size)

        offset = 1 if p == 1 else  ((p - 1) * revcount + 1)

        try:

        except IndexError:

        rev_start = max(0, rev_end - revcount)

        data = []

        rev_end += 1

        if repo.alias == 'git':

            for _ in xrange(rev_start, rev_end):

                vtx = [0, 1]

                edges = [[0, 0, 1]]

                data.append(['', vtx, edges])

        elif repo.alias == 'hg':

            revs = list(reversed(xrange(rev_start, rev_end)))

            c.dag = graphmod.colored(graphmod.dagwalker(repo._repo, revs))

            for (id, type, ctx, vtx, edges) in c.dag:

                if type != graphmod.CHANGESET:

                    continue

                data.append(['', vtx, edges])

        c.jsdata = json.dumps(data)

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

"""

    rhodecode.controllers.changeset

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

    changeset controller for pylons showoing changes beetween

    revisions

    :created_on: Apr 25, 2010

    :author: marcink

    :copyright: (C) 2009-2011 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

import traceback

from pylons import tmpl_context as c, url, request, response

from pylons.i18n.translation import _

from pylons.controllers.util import redirect

import rhodecode.lib.helpers as h

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.utils import EmptyChangeset

from rhodecode.lib.compat import OrderedDict

from vcs.exceptions import RepositoryError, ChangesetError, \

ChangesetDoesNotExistError

from vcs.nodes import FileNode

from vcs.utils import diffs as differ

log = logging.getLogger(__name__)

class ChangesetController(BaseRepoController):

    @LoginRequired()

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

                                   'repository.admin')

    def __before__(self):

        super(ChangesetController, self).__before__()

        c.affected_files_cut_off = 60

    def index(self, revision):

        def wrap_to_table(str):

            return '''<table class="code-difftable">

                        <tr class="line">

                        <td class="lineno new"></td>

                        <td class="code"><pre>%s</pre></td>

                        </tr>

                      </table>''' % str

        #get ranges of revisions if preset

        rev_range = revision.split('...')[:2]

        try:

            if len(rev_range) == 2:

                rev_start = rev_range[0]

                rev_end = rev_range[1]

                rev_ranges = c.rhodecode_repo.get_changesets(start=rev_start,

                                                            end=rev_end)

            else:

                rev_ranges = [c.rhodecode_repo.get_changeset(revision)]

            c.cs_ranges = list(rev_ranges)

        except (RepositoryError, ChangesetDoesNotExistError, Exception), e:

            log.error(traceback.format_exc())

            h.flash(str(e), category='warning')

            return redirect(url('home'))

        c.changes = OrderedDict()

        c.sum_added = 0

        c.sum_removed = 0

        c.lines_added = 0

        c.lines_deleted = 0

        c.cut_off = False  # defines if cut off limit is reached

        # Iterate over ranges (default changeset view is always one changeset)

        for changeset in c.cs_ranges:

            c.changes[changeset.raw_id] = []

            try:

                changeset_parent = changeset.parents[0]

            except IndexError:

                changeset_parent = None

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

            # ADDED FILES

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

            for node in changeset.added:

                filenode_old = FileNode(node.path, '', EmptyChangeset())

                if filenode_old.is_binary or node.is_binary:

                    diff = wrap_to_table(_('binary file'))

                    st = (0, 0)

                else:

                    # in this case node.size is good parameter since those are

                    # added nodes and their size defines how many changes were

                    # made

                    c.sum_added += node.size

                    if c.sum_added < self.cut_off_limit:

                        f_gitdiff = differ.get_gitdiff(filenode_old, node)

                        d = differ.DiffProcessor(f_gitdiff, format='gitdiff')

                        st = d.stat()

                        diff = d.as_html()

                    else:

                        diff = wrap_to_table(_('Changeset is to big and '

                                               'was cut off, see raw '

                                               'changeset instead'))

                        c.cut_off = True

                        break

                cs1 = None

                cs2 = node.last_changeset.raw_id

                c.lines_added += st[0]

                c.lines_deleted += st[1]

                c.changes[changeset.raw_id].append(('added', node, diff,

                                                    cs1, cs2, st))

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

            # CHANGED FILES

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

            if not c.cut_off:

                for node in changeset.changed:

                    try:

                        filenode_old = changeset_parent.get_node(node.path)

                    except ChangesetError:

                        log.warning('Unable to fetch parent node for diff')

                        filenode_old = FileNode(node.path, '',

                                                EmptyChangeset())

                    if filenode_old.is_binary or node.is_binary:

                        diff = wrap_to_table(_('binary file'))

                        st = (0, 0)

                    else:

                        if c.sum_removed < self.cut_off_limit:

                            f_gitdiff = differ.get_gitdiff(filenode_old, node)

                            d = differ.DiffProcessor(f_gitdiff,

                                                     format='gitdiff')

                            st = d.stat()

                            if (st[0] + st[1]) * 256 > self.cut_off_limit:

                                diff = wrap_to_table(_('Diff is to big '

                                                       'and was cut off, see '

                                                       'raw diff instead'))

                            else:

                                diff = d.as_html()

                            if diff:

                                c.sum_removed += len(diff)

                        else:

                            diff = wrap_to_table(_('Changeset is to big and '

                                                   'was cut off, see raw '

                                                   'changeset instead'))

                            c.cut_off = True

                            break

                    cs1 = filenode_old.last_changeset.raw_id

                    cs2 = node.last_changeset.raw_id

                    c.lines_added += st[0]

                    c.lines_deleted += st[1]

                    c.changes[changeset.raw_id].append(('changed', node, diff,

                                                        cs1, cs2, st))

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

            # REMOVED FILES

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

            if not c.cut_off:

                for node in changeset.removed:

                    c.changes[changeset.raw_id].append(('removed', node, None,

                                                        None, None, (0, 0)))

        if len(c.cs_ranges) == 1:

            c.changeset = c.cs_ranges[0]

            c.changes = c.changes[c.changeset.raw_id]

            return render('changeset/changeset.html')

        else:

            return render('changeset/changeset_range.html')

    def raw_changeset(self, revision):

        method = request.GET.get('diff', 'show')

        try:

            c.scm_type = c.rhodecode_repo.alias

            c.changeset = c.rhodecode_repo.get_changeset(revision)

        except RepositoryError:

            log.error(traceback.format_exc())

            return redirect(url('home'))

        else:

            try:

                c.changeset_parent = c.changeset.parents[0]

            except IndexError:

                c.changeset_parent = None

            c.changes = []

            for node in c.changeset.added:

                filenode_old = FileNode(node.path, '')

                if filenode_old.is_binary or node.is_binary:

                    diff = _('binary file') + '\n'

                else:

                    f_gitdiff = differ.get_gitdiff(filenode_old, node)

                    diff = differ.DiffProcessor(f_gitdiff,

                                                format='gitdiff').raw_diff()

                cs1 = None

                cs2 = node.last_changeset.raw_id

                c.changes.append(('added', node, diff, cs1, cs2))

            for node in c.changeset.changed:

                filenode_old = c.changeset_parent.get_node(node.path)

                if filenode_old.is_binary or node.is_binary:

                    diff = _('binary file')

                else:

                    f_gitdiff = differ.get_gitdiff(filenode_old, node)

                    diff = differ.DiffProcessor(f_gitdiff,

                                                format='gitdiff').raw_diff()

                cs1 = filenode_old.last_changeset.raw_id

                cs2 = node.last_changeset.raw_id

                c.changes.append(('changed', node, diff, cs1, cs2))

        response.content_type = 'text/plain'

        if method == 'download':

            response.content_disposition = 'attachment; filename=%s.patch' \

                                            % revision

        c.parent_tmpl = ''.join(['# Parent  %s\n' % x.raw_id for x in

                                                 c.changeset.parents])

        c.diffs = ''

        for x in c.changes:

            c.diffs += x[2]

        return render('changeset/raw_changeset.html')

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

"""

    rhodecode.controllers.shortlog

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

    Shortlog controller for rhodecode

    :created_on: Apr 18, 2010

    :author: marcink

    :copyright: (C) 2009-2011 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 tmpl_context as c, request, url

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.helpers import RepoPage

log = logging.getLogger(__name__)

class ShortlogController(BaseRepoController):

    @LoginRequired()

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

                                   'repository.admin')

    def __before__(self):

        super(ShortlogController, self).__before__()

    def index(self, repo_name):

        p = int(request.params.get('page', 1))

        size = int(request.params.get('size', 20))

        def url_generator(**kw):

            return url('shortlog_home', repo_name=repo_name, size=size, **kw)

        c.repo_changesets = RepoPage(c.rhodecode_repo, page=p,

        c.shortlog_data = render('shortlog/shortlog_data.html')

        if request.environ.get('HTTP_X_PARTIAL_XHR'):

            return c.shortlog_data

        r = render('shortlog/shortlog.html')

        return r

        if isinstance(paths, str):

            paths = safe_unicode(paths)

        url_l = [link_to(repo_name, url('files_home',

                                        repo_name=repo_name,

                                        revision=rev, f_path=''))]

        paths_l = paths.split('/')

        for cnt, p in enumerate(paths_l):

            if p != '':

                url_l.append(link_to(p, url('files_home',

                                            repo_name=repo_name,

                                            revision=rev,

                                            f_path='/'.join(paths_l[:cnt + 1]))))

        return literal('/'.join(url_l))

files_breadcrumbs = _FilesBreadCrumbs()

class CodeHtmlFormatter(HtmlFormatter):

    """My code Html Formatter for source codes

    """

    def wrap(self, source, outfile):

        return self._wrap_div(self._wrap_pre(self._wrap_code(source)))

    def _wrap_code(self, source):

        for cnt, it in enumerate(source):

            i, t = it

            t = '<div id="L%s">%s</div>' % (cnt + 1, t)

            yield i, t

    def _wrap_tablelinenos(self, inner):

        dummyoutfile = StringIO.StringIO()

        lncount = 0

        for t, line in inner:

            if t:

                lncount += 1

            dummyoutfile.write(line)

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

def pygmentize(filenode, **kwargs):

    """pygmentize function using pygments

    :param filenode:

    """

    return literal(code_highlight(filenode.content,

                                  filenode.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 color_dict.has_key(cs):

            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 vcs.utils import author_name, author_email

from rhodecode.lib import credentials_filter, age as _age

age = lambda  x:_age(x)

capitalize = lambda x: x.capitalize()

email = author_email

email_or_none = lambda x: email(x) if email(x) != x else None

person = lambda x: author_name(x)

short_id = lambda x: x[:12]

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

def bool2icon(value):

    """Returns True/False values represented as small html image of true/false

    icons

    :param value: bool value

    """

    if value is True:

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

                        alt=_('True'))

    if value is False:

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

                        alt=_('False'))

    return value

def action_parser(user_log, feed=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)

    """

    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 = action_params.split(',')

        repo_name = user_log.repository.repo_name

        from rhodecode.model.scm import ScmModel

        repo = user_log.repository.scm_instance

        message = lambda rev: get_changeset_safe(repo, rev).message

        cs_links = []

        cs_links.append(" " + ', '.join ([link_to(rev,

                url('changeset_home',

                repo_name=repo_name,

                revision=rev), title=tooltip(message(rev)),

                class_='tooltip') for rev in revs[:revs_limit] ]))

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

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

                        '</div>' % (_('Show all combined changesets %s->%s' \

                                      % (revs[0], revs[-1])),

                                    url('changeset_home', repo_name=repo_name,

                                        revision='%s...%s' % (revs[0], revs[-1])

                                    ),

                                    _('compare view'))

                        )

        if len(revs) > revs_limit:

            uniq_id = revs[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) - revs_limit),

                                        _('revisions')))

            if not feed:

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

            else:

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

            cs_links.append(html_tmpl % (uniq_id, ', '.join([link_to(rev,

                url('changeset_home',

                repo_name=repo_name, revision=rev),

                title=message(rev), class_='tooltip')

                for rev in revs[revs_limit:revs_top_limit]])))

        if len(revs) > 1:

            cs_links.append(compare_view)

        return ''.join(cs_links)

    def get_fork_name():

        repo_name = action_params

        return _('fork name ') + str(link_to(action_params, url('summary_home',

                                          repo_name=repo_name,)))

    action_map = {'user_deleted_repo':(_('[deleted] repository'), None),

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

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

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

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

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

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

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

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

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

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

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

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

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

            }

    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]

    return [literal(action), action_params_func]

def action_parser_icon(user_log):

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

    map = {'user_deleted_repo':'database_delete.png',

           'user_created_repo':'database_add.png',

           'user_forked_repo':'arrow_divide.png',

           'user_updated_repo':'database_edit.png',

           'admin_deleted_repo':'database_delete.png',

           'admin_created_repo':'database_add.png',

           'admin_forked_repo':'arrow_divide.png',

           'admin_updated_repo':'database_edit.png',

           'push':'script_add.png',

           'push_local':'script_edit.png',

           'push_remote':'connect.png',

           'pull':'down_16.png',

           'started_following_repo':'heart_add.png',

           'stopped_following_repo':'heart_delete.png',

            }

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

                           map.get(action, action), action))

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

# PERMS

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

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

HasRepoPermissionAny, HasRepoPermissionAll

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

# GRAVATAR URL

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

def gravatar_url(email_address, size=30):

    if (not str2bool(config['app_conf'].get('use_gravatar')) or

        not email_address or email_address == 'anonymous@rhodecode.org'):

        return url("/images/user%s.png" % size)

    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

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

# REPO PAGER, PAGER FOR REPOSITORY

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

class RepoPage(Page):

    def __init__(self, collection, page=1, items_per_page=20,

        """Create a "RepoPage" instance. special pager for paging

        repository

        """

        self._url_generator = url

        # Safe the kwargs class-wide so they can be used in the pager() method