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

"""

    rhodecode.controllers.summary

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

    Summary controller for Rhodecode

    :created_on: Apr 18, 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 traceback

import calendar

import logging

import urllib

from time import mktime

from datetime import timedelta, date

from urlparse import urlparse

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

from pylons.i18n.translation import _

from webob.exc import HTTPBadRequest

from beaker.cache import cache_region, region_invalidate

from rhodecode.lib.compat import product

from rhodecode.lib.vcs.exceptions import ChangesetError, EmptyRepositoryError, \

    NodeDoesNotExistError

from rhodecode.config.conf import ALL_READMES, ALL_EXTS, LANGUAGES_EXTENSIONS_MAP

from rhodecode.model.db import Statistics, CacheInvalidation

from rhodecode.lib.utils import jsonify

from rhodecode.lib.utils2 import safe_unicode

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator,\

    NotAnonymous

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.vcs.backends.base import EmptyChangeset

from rhodecode.lib.markup_renderer import MarkupRenderer

from rhodecode.lib.celerylib import run_task

from rhodecode.lib.celerylib.tasks import get_commits_stats

from rhodecode.lib.helpers import RepoPage

from rhodecode.lib.compat import json, OrderedDict

from rhodecode.lib.vcs.nodes import FileNode

log = logging.getLogger(__name__)

README_FILES = [''.join([x[0][0], x[1][0]]) for x in

                    sorted(list(product(ALL_READMES, ALL_EXTS)),

                           key=lambda y:y[0][1] + y[1][1])]

class SummaryController(BaseRepoController):

    @LoginRequired()

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

                                   'repository.admin')

    def __before__(self):

        super(SummaryController, self).__before__()

    def index(self, repo_name):

        c.dbrepo = dbrepo = c.rhodecode_db_repo

        def url_generator(**kw):

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

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

                                     items_per_page=10, url=url_generator)

        page_revisions = [x.raw_id for x in list(c.repo_changesets)]

        c.statuses = c.rhodecode_db_repo.statuses(page_revisions)

        if self.rhodecode_user.username == 'default':

            # for default(anonymous) user we don't need to pass credentials

            username = ''

            password = ''

        else:

            username = str(self.rhodecode_user.username)

            password = '@'

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

        default_clone_uri = '{scheme}://{user}{pass}{netloc}{path}'

        uri_tmpl = config.get('clone_uri', default_clone_uri)

        uri_tmpl = uri_tmpl.replace('{', '%(').replace('}', ')s')

        decoded_path = safe_unicode(urllib.unquote(parsed_url.path))

        uri_dict = {

           'user': urllib.quote(username),

           'pass': password,

           'scheme': parsed_url.scheme,

           'netloc': parsed_url.netloc,

           'path': decoded_path

        }

        uri = uri_tmpl % uri_dict

        # generate another clone url by id

        uri_dict.update(

         {'path': decoded_path.replace(repo_name, '_%s' % c.dbrepo.repo_id)}

        )

        uri_id = uri_tmpl % uri_dict

        c.clone_repo_url = uri

        c.clone_repo_url_id = uri_id

        c.repo_tags = OrderedDict()

        for name, hash_ in c.rhodecode_repo.tags.items()[:10]:

            try:

                c.repo_tags[name] = c.rhodecode_repo.get_changeset(hash_)

            except ChangesetError:

                c.repo_tags[name] = EmptyChangeset(hash_)

        c.repo_branches = OrderedDict()

        for name, hash_ in c.rhodecode_repo.branches.items()[:10]:

            try:

                c.repo_branches[name] = c.rhodecode_repo.get_changeset(hash_)

            except ChangesetError:

                c.repo_branches[name] = EmptyChangeset(hash_)

        td = date.today() + timedelta(days=1)

        td_1m = td - timedelta(days=calendar.mdays[td.month])

        td_1y = td - timedelta(days=365)

        ts_min_m = mktime(td_1m.timetuple())

        ts_min_y = mktime(td_1y.timetuple())

        ts_max_y = mktime(td.timetuple())

        if dbrepo.enable_statistics:

            c.show_stats = True

            c.no_data_msg = _('No data loaded yet')

            recurse_limit = 500  # don't recurse more than 500 times when parsing

            run_task(get_commits_stats, c.dbrepo.repo_name, ts_min_y,

                     ts_max_y, recurse_limit)

        else:

            c.show_stats = False

            c.no_data_msg = _('Statistics are disabled for this repository')

        c.ts_min = ts_min_m

        c.ts_max = ts_max_y

        stats = self.sa.query(Statistics)\

            .filter(Statistics.repository == dbrepo)\

            .scalar()

        c.stats_percentage = 0

        if stats and stats.languages:

            c.no_data = False is dbrepo.enable_statistics

            lang_stats_d = json.loads(stats.languages)

            c.commit_data = stats.commit_activity

            c.overview_data = stats.commit_activity_combined

            lang_stats = ((x, {"count": y,

                               "desc": LANGUAGES_EXTENSIONS_MAP.get(x)})

                          for x, y in lang_stats_d.items())

            c.trending_languages = json.dumps(

                sorted(lang_stats, reverse=True, key=lambda k: k[1])[:10]

            )

            last_rev = stats.stat_on_revision + 1

            c.repo_last_rev = c.rhodecode_repo.count()\

                if c.rhodecode_repo.revisions else 0

            if last_rev == 0 or c.repo_last_rev == 0:

                pass

            else:

                c.stats_percentage = '%.2f' % ((float((last_rev)) /

                                                c.repo_last_rev) * 100)

        else:

            c.commit_data = json.dumps({})

            c.overview_data = json.dumps([[ts_min_y, 0], [ts_max_y, 10]])

            c.trending_languages = json.dumps({})

            c.no_data = True

        c.enable_downloads = dbrepo.enable_downloads

        if c.enable_downloads:

            c.download_options = self._get_download_links(c.rhodecode_repo)

        c.readme_data, c.readme_file = \

            self.__get_readme_data(c.rhodecode_db_repo)

        return render('summary/summary.html')

    @NotAnonymous()

    @jsonify

    def repo_size(self, repo_name):

        if request.is_xhr:

            return _('repository size: %s') % c.rhodecode_db_repo._repo_size()

        else:

            raise HTTPBadRequest()

    def __get_readme_data(self, db_repo):

        repo_name = db_repo.repo_name

        @cache_region('long_term')

        def _get_readme_from_cache(key):

            readme_data = None

            readme_file = None

            log.debug('Looking for README file')

            try:

                # get's the landing revision! or tip if fails

                cs = db_repo.get_landing_changeset()

                if isinstance(cs, EmptyChangeset):

                    raise EmptyRepositoryError()

                renderer = MarkupRenderer()

                for f in README_FILES:

                    try:

                        readme = cs.get_node(f)

                        if not isinstance(readme, FileNode):

                            continue

                        readme_file = f

                        log.debug('Found README file `%s` rendering...' %

                                  readme_file)

                        readme_data = renderer.render(readme.content, f)

                        break

                    except NodeDoesNotExistError:

                        continue

            except ChangesetError:

                log.error(traceback.format_exc())

                pass

            except EmptyRepositoryError:

                pass

            except Exception:

                log.error(traceback.format_exc())

            return readme_data, readme_file

        key = repo_name + '_README'

        inv = CacheInvalidation.invalidate(key)

        if inv is not None:

            region_invalidate(_get_readme_from_cache, None, key)

            CacheInvalidation.set_valid(inv.cache_key)

        return _get_readme_from_cache(key)

    def _get_download_links(self, repo):

        download_l = []

        branches_group = ([], _("Branches"))

        tags_group = ([], _("Tags"))

        for name, chs in c.rhodecode_repo.branches.items():

            #chs = chs.split(':')[-1]

            branches_group[0].append((chs, name),)

        download_l.append(branches_group)

        for name, chs in c.rhodecode_repo.tags.items():

            #chs = chs.split(':')[-1]

            tags_group[0].append((chs, name),)

        download_l.append(tags_group)

        return download_l

"""The base Controller API

Provides the BaseController class for subclassing.

"""

import logging

import time

import traceback

from paste.auth.basic import AuthBasicAuthenticator

from paste.httpexceptions import HTTPUnauthorized, HTTPForbidden

from paste.httpheaders import WWW_AUTHENTICATE, AUTHORIZATION

from pylons import config, tmpl_context as c, request, session, url

from pylons.controllers import WSGIController

from pylons.controllers.util import redirect

from pylons.templating import render_mako as render

from rhodecode import __version__, BACKENDS

from rhodecode.lib.utils2 import str2bool, safe_unicode, AttributeDict,\

    safe_str, safe_int

from rhodecode.lib.auth import AuthUser, get_container_username, authfunc,\

    HasPermissionAnyMiddleware, CookieStoreWrapper

from rhodecode.lib.utils import get_repo_slug, invalidate_cache

from rhodecode.model import meta

from rhodecode.model.db import Repository, RhodeCodeUi, User, RhodeCodeSetting

from rhodecode.model.notification import NotificationModel

from rhodecode.model.scm import ScmModel

from rhodecode.model.meta import Session

log = logging.getLogger(__name__)

def _get_ip_addr(environ):

    proxy_key = 'HTTP_X_REAL_IP'

    proxy_key2 = 'HTTP_X_FORWARDED_FOR'

    def_key = 'REMOTE_ADDR'

    ip = environ.get(proxy_key)

    if ip:

        return ip

    ip = environ.get(proxy_key2)

    if ip:

        return ip

    ip = environ.get(def_key, '0.0.0.0')

    # HEADERS can have mutliple ips inside

    # the left-most being the original client, and each successive proxy

    # that passed the request adding the IP address where it received the

    # request from.

    if ',' in ip:

        ip = ip.split(',')[0].strip()

    return ip

def _get_access_path(environ):

    path = environ.get('PATH_INFO')

    org_req = environ.get('pylons.original_request')

    if org_req:

        path = org_req.environ.get('PATH_INFO')

    return path

class BasicAuth(AuthBasicAuthenticator):

    def __init__(self, realm, authfunc, auth_http_code=None):

        self.realm = realm

        self.authfunc = authfunc

        self._rc_auth_http_code = auth_http_code

    def build_authentication(self):

        head = WWW_AUTHENTICATE.tuples('Basic realm="%s"' % self.realm)

        if self._rc_auth_http_code and self._rc_auth_http_code == '403':

            # return 403 if alternative http return code is specified in

            # RhodeCode config

            return HTTPForbidden(headers=head)

        return HTTPUnauthorized(headers=head)

    def authenticate(self, environ):

        authorization = AUTHORIZATION(environ)

        if not authorization:

            return self.build_authentication()

        (authmeth, auth) = authorization.split(' ', 1)

        if 'basic' != authmeth.lower():

            return self.build_authentication()

        auth = auth.strip().decode('base64')

        _parts = auth.split(':', 1)

        if len(_parts) == 2:

            username, password = _parts

            if self.authfunc(environ, username, password):

                return username

        return self.build_authentication()

    __call__ = authenticate

class BaseVCSController(object):

    def __init__(self, application, config):

        self.application = application

        self.config = config

        # base path of repo locations

        self.basepath = self.config['base_path']

        #authenticate this mercurial request using authfunc

        self.authenticate = BasicAuth('', authfunc,

                                      config.get('auth_ret_code'))

        self.ip_addr = '0.0.0.0'

    def _handle_request(self, environ, start_response):

        raise NotImplementedError()

    def _get_by_id(self, repo_name):

        """

        Get's a special pattern _<ID> from clone url and tries to replace it

        with a repository_name for support of _<ID> non changable urls

        :param repo_name:

        """

        try:

            data = repo_name.split('/')

            if len(data) >= 2:

                by_id = data[1].split('_')

                if len(by_id) == 2 and by_id[1].isdigit():

                    _repo_name = Repository.get(by_id[1]).repo_name

                    data[1] = _repo_name

        except:

            log.debug('Failed to extract repo_name from id %s' % (

                      traceback.format_exc()

                      )

            )

        return '/'.join(data)

    def _invalidate_cache(self, repo_name):

        """

        Set's cache for this repository for invalidation on next access

        :param repo_name: full repo name, also a cache key

        """

        invalidate_cache('get_repo_cached_%s' % repo_name)

    def _check_permission(self, action, user, repo_name, ip_addr=None):

        """

        Checks permissions using action (push/pull) user and repository

        name

        :param action: push or pull action

        :param user: user instance

        :param repo_name: repository name

        """

        #check IP

        authuser = AuthUser(user_id=user.user_id, ip_addr=ip_addr)

        if not authuser.ip_allowed:

            return False

        else:

            log.info('Access for IP:%s allowed' % (ip_addr))

        if action == 'push':

            if not HasPermissionAnyMiddleware('repository.write',

                                              'repository.admin')(user,

                                                                  repo_name):

                return False

        else:

            #any other action need at least read permission

            if not HasPermissionAnyMiddleware('repository.read',

                                              'repository.write',

                                              'repository.admin')(user,

                                                                  repo_name):

                return False

        return True

    def _get_ip_addr(self, environ):

        return _get_ip_addr(environ)

    def _check_ssl(self, environ, start_response):

        """

        Checks the SSL check flag and returns False if SSL is not present

        and required True otherwise

        """

        org_proto = environ['wsgi._org_proto']

        #check if we have SSL required  ! if not it's a bad request !

        require_ssl = str2bool(RhodeCodeUi.get_by_key('push_ssl').ui_value)

        if require_ssl and org_proto == 'http':

            log.debug('proto is %s and SSL is required BAD REQUEST !'

                      % org_proto)

            return False

        return True

    def _check_locking_state(self, environ, action, repo, user_id):

        """

        Checks locking on this repository, if locking is enabled and lock is

        present returns a tuple of make_lock, locked, locked_by.

        make_lock can have 3 states None (do nothing) True, make lock

        False release lock, This value is later propagated to hooks, which

        do the locking. Think about this as signals passed to hooks what to do.

        """

        locked = False  # defines that locked error should be thrown to user

        make_lock = None

        repo = Repository.get_by_repo_name(repo)

        user = User.get(user_id)

        # this is kind of hacky, but due to how mercurial handles client-server

        # server see all operation on changeset; bookmarks, phases and

        # obsolescence marker in different transaction, we don't want to check

        # locking on those

        obsolete_call = environ['QUERY_STRING'] in ['cmd=listkeys',]

        locked_by = repo.locked

        if repo and repo.enable_locking and not obsolete_call:

            if action == 'push':

                #check if it's already locked !, if it is compare users

                user_id, _date = repo.locked

                if user.user_id == user_id:

                    log.debug('Got push from user %s, now unlocking' % (user))

                    # unlock if we have push from user who locked

                    make_lock = False

                else:

                    # we're not the same user who locked, ban with 423 !

                    locked = True

            if action == 'pull':

                if repo.locked[0] and repo.locked[1]:

                    locked = True

                else:

                    log.debug('Setting lock on repo %s by %s' % (repo, user))

                    make_lock = True

        else:

            log.debug('Repository %s do not have locking enabled' % (repo))

        log.debug('FINAL locking values make_lock:%s,locked:%s,locked_by:%s'

                  % (make_lock, locked, locked_by))

        return make_lock, locked, locked_by

    def __call__(self, environ, start_response):

        start = time.time()

        try:

            return self._handle_request(environ, start_response)

        finally:

            log = logging.getLogger('rhodecode.' + self.__class__.__name__)

            log.debug('Request time: %.3fs' % (time.time() - start))

            meta.Session.remove()

class BaseController(WSGIController):

    def __before__(self):

        """

        __before__ is called before controller methods and after __call__

        """

        c.rhodecode_version = __version__

        c.rhodecode_instanceid = config.get('instance_id')

        c.rhodecode_name = config.get('rhodecode_title')

        c.use_gravatar = str2bool(config.get('use_gravatar'))

        c.ga_code = config.get('rhodecode_ga_code')

        # Visual options

        c.visual = AttributeDict({})

        rc_config = RhodeCodeSetting.get_app_settings()

        c.visual.show_public_icon = str2bool(rc_config.get('rhodecode_show_public_icon'))

        c.visual.show_private_icon = str2bool(rc_config.get('rhodecode_show_private_icon'))

        c.visual.stylify_metatags = str2bool(rc_config.get('rhodecode_stylify_metatags'))

        c.visual.lightweight_dashboard = str2bool(rc_config.get('rhodecode_lightweight_dashboard'))

        c.visual.lightweight_dashboard_items = safe_int(config.get('dashboard_items', 100))

        c.visual.repository_fields = str2bool(rc_config.get('rhodecode_repository_fields'))

        c.repo_name = get_repo_slug(request)

        c.backends = BACKENDS.keys()

        c.unread_notifications = NotificationModel()\

                        .get_unread_cnt_for_user(c.rhodecode_user.user_id)

        self.cut_off_limit = int(config.get('cut_off_limit'))

        self.sa = meta.Session

        self.scm_model = ScmModel(self.sa)

    def __call__(self, environ, start_response):

        """Invoke the Controller"""

        # WSGIController.__call__ dispatches to the Controller method

        # the request is routed to. This routing information is

        # available in environ['pylons.routes_dict']

        try:

            self.ip_addr = _get_ip_addr(environ)

            # make sure that we update permissions each time we call controller

            api_key = request.GET.get('api_key')

            cookie_store = CookieStoreWrapper(session.get('rhodecode_user'))

            user_id = cookie_store.get('user_id', None)

            username = get_container_username(environ, config)

            auth_user = AuthUser(user_id, api_key, username, self.ip_addr)

            request.user = auth_user

            self.rhodecode_user = c.rhodecode_user = auth_user

            if not self.rhodecode_user.is_authenticated and \

                       self.rhodecode_user.user_id is not None:

                self.rhodecode_user.set_authenticated(

                    cookie_store.get('is_authenticated')

                )

            log.info('IP: %s User: %s accessed %s' % (

               self.ip_addr, auth_user, safe_unicode(_get_access_path(environ)))

            )

            return WSGIController.__call__(self, environ, start_response)

        finally:

            meta.Session.remove()

class BaseRepoController(BaseController):

    """

    Base class for controllers responsible for loading all needed data for

    repository loaded items are

    c.rhodecode_repo: instance of scm repository

    c.rhodecode_db_repo: instance of db

    c.repository_followers: number of followers

    c.repository_forks: number of forks

    """

    def __before__(self):

        super(BaseRepoController, self).__before__()

        if c.repo_name:

            dbr = c.rhodecode_db_repo = Repository.get_by_repo_name(c.repo_name)

            c.rhodecode_repo = c.rhodecode_db_repo.scm_instance

            # update last change according to VCS data

            dbr.update_changeset_cache(dbr.get_changeset())

            if c.rhodecode_repo is None:

                log.error('%s this repository is present in database but it '

                          'cannot be created as an scm instance', c.repo_name)

                redirect(url('home'))

            # some globals counter for menu

            c.repository_followers = self.scm_model.get_followers(dbr)

            c.repository_forks = self.scm_model.get_forks(dbr)

            c.repository_pull_requests = self.scm_model.get_pull_requests(dbr)

"""Helper functions

Consists of functions to typically be used within templates, but also

available to Controllers. This module is available to both as 'h'.

"""

import random

import hashlib

import StringIO

import urllib

import math

import logging

import re

import urlparse

import textwrap

from datetime import datetime

from pygments.formatters.html import HtmlFormatter

from pygments import highlight as code_highlight

from pylons import url, request, config

from pylons.i18n.translation import _, ungettext

from hashlib import md5

from webhelpers.html import literal, HTML, escape

from webhelpers.html.tools import *

from webhelpers.html.builder import make_tag

from webhelpers.html.tags import auto_discovery_link, checkbox, css_classes, \

    end_form, file, form, hidden, image, javascript_link, link_to, \

    link_to_if, link_to_unless, ol, required_legend, select, stylesheet_link, \

    submit, text, password, textarea, title, ul, xml_declaration, radio

from webhelpers.html.tools import auto_link, button_to, highlight, \

    js_obfuscate, mail_to, strip_links, strip_tags, tag_re

from webhelpers.number import format_byte_size, format_bit_size

from webhelpers.pylonslib import Flash as _Flash

from webhelpers.pylonslib.secure_form import secure_form

from webhelpers.text import chop_at, collapse, convert_accented_entities, \

    convert_misc_entities, lchop, plural, rchop, remove_formatting, \

    replace_whitespace, urlify, truncate, wrap_paragraphs

from webhelpers.date import time_ago_in_words

from webhelpers.paginate import Page

from webhelpers.html.tags import _set_input_attrs, _set_id_attr, \

    convert_boolean_attrs, NotGiven, _make_safe_id_component

from rhodecode.lib.annotate import annotate_highlight

from rhodecode.lib.utils import repo_name_slug, get_custom_lexer

from rhodecode.lib.utils2 import str2bool, safe_unicode, safe_str, \

    get_changeset_safe, datetime_to_time, time_to_datetime, AttributeDict

from rhodecode.lib.markup_renderer import MarkupRenderer

from rhodecode.lib.vcs.exceptions import ChangesetDoesNotExistError

from rhodecode.lib.vcs.backends.base import BaseChangeset, EmptyChangeset

from rhodecode.config.conf import DATE_FORMAT, DATETIME_FORMAT

from rhodecode.model.changeset_status import ChangesetStatusModel

from rhodecode.model.db import URL_SEP, Permission

log = logging.getLogger(__name__)

html_escape_table = {

    "&": "&",

    '"': """,

    "'": "'",

    ">": ">",

    "<": "&lt;",

}

def html_escape(text):

    """Produce entities within text."""

    return "".join(html_escape_table.get(c, c) for c in text)

def shorter(text, size=20):

    postfix = '...'

    if len(text) > size:

        return text[:size - len(postfix)] + postfix

    return text

def _reset(name, value=None, id=NotGiven, type="reset", **attrs):

    """

    Reset button

    """

    _set_input_attrs(attrs, type, name, value)

    _set_id_attr(attrs, id, name)

    convert_boolean_attrs(attrs, ["disabled"])

    return HTML.input(**attrs)

reset = _reset

safeid = _make_safe_id_component

def FID(raw_id, path):

    """

    Creates a uniqe ID for filenode based on it's hash of path and revision

    it's safe to use in urls

    :param raw_id:

    :param path:

    """

    return 'C-%s-%s' % (short_id(raw_id), md5(safe_str(path)).hexdigest()[:12])

def get_token():

    """Return the current authentication token, creating one if one doesn't

    already exist.

    """

    token_key = "_authentication_token"

    from pylons import session

    if not token_key in session:

        try:

            token = hashlib.sha1(str(random.getrandbits(128))).hexdigest()

        except AttributeError:  # Python < 2.4

            token = hashlib.sha1(str(random.randrange(2 ** 128))).hexdigest()

        session[token_key] = token

        if hasattr(session, 'save'):

            session.save()

    return session[token_key]

class _GetError(object):

    """Get error from form_errors, and represent it as span wrapped error

    message

    :param field_name: field to fetch errors for

    :param form_errors: form errors dict

    """

    def __call__(self, field_name, form_errors):

        tmpl = """<span class="error_msg">%s</span>"""

        if form_errors and field_name in form_errors:

            return literal(tmpl % form_errors.get(field_name))

get_error = _GetError()

class _ToolTip(object):

    def __call__(self, tooltip_title, trim_at=50):

        """

        Special function just to wrap our text into nice formatted

        autowrapped text

        :param tooltip_title:

        """

        tooltip_title = escape(tooltip_title)

        tooltip_title = tooltip_title.replace('<', '&lt;').replace('>', '&gt;')

        return tooltip_title

tooltip = _ToolTip()

class _FilesBreadCrumbs(object):

    def __call__(self, repo_name, rev, paths):

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

                         class_='ypjax-link')]

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

                                         ),

                                     class_='ypjax-link'

                                     )

                             )

        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:

    """

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