from kallithea.model.meta import Session

from kallithea.model.repo_group import RepoGroupModel

from kallithea.lib.utils2 import safe_str, safe_unicode, get_current_authuser

from kallithea.lib.vcs.utils.fakemod import create_module

log = logging.getLogger(__name__)

REMOVED_REPO_PAT = re.compile(r'rm__\d{8}_\d{6}_\d{6}_.*')

def recursive_replace(str_, replace=' '):

    """

    Recursive replace of given sign to just one instance

    :param str_: given string

    :param replace: char to find and replace multiple instances

    Examples::

    >>> recursive_replace("Mighty---Mighty-Bo--sstones",'-')

    'Mighty-Mighty-Bo-sstones'

    """

    if str_.find(replace * 2) == -1:

        return str_

    else:

        str_ = str_.replace(replace * 2, replace)

        return recursive_replace(str_, replace)

def repo_name_slug(value):

    """

    Return slug of name of repository

    This function is called on each creation/modification

    of repository to prevent bad names in repo

    """

    slug = remove_formatting(value)

    slug = strip_tags(slug)

    for c in """`?=[]\;'"<>,/~!@#$%^&*()+{}|: """:

        slug = slug.replace(c, '-')

    slug = recursive_replace(slug, '-')

    slug = collapse(slug, '-')

    return slug

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

# PERM DECORATOR HELPERS FOR EXTRACTING NAMES FOR PERM CHECKS

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

def get_repo_slug(request):

    _repo = request.environ['pylons.routes_dict'].get('repo_name')

    if _repo:

        _repo = _repo.rstrip('/')

    return _repo

def get_repo_group_slug(request):

    _group = request.environ['pylons.routes_dict'].get('group_name')

    if _group:

        _group = _group.rstrip('/')

    return _group

def get_user_group_slug(request):

    _group = request.environ['pylons.routes_dict'].get('id')

    _group = UserGroup.get(_group)

    if _group:

        return _group.users_group_name

    return None

def _extract_id_from_repo_name(repo_name):

    if repo_name.startswith('/'):

        repo_name = repo_name.lstrip('/')

    by_id_match = re.match(r'^_(\d{1,})', repo_name)

    if by_id_match:

        return by_id_match.groups()[0]

def get_repo_by_id(repo_name):

    """

    Extracts repo_name by id from special urls. Example url is _11/repo_name

    :param repo_name:

    :return: repo_name if matched else None

    """

    _repo_id = _extract_id_from_repo_name(repo_name)

    if _repo_id:

        from kallithea.model.db import Repository

        repo = Repository.get(_repo_id)

        if repo:

            # TODO: return repo instead of reponame? or would that be a layering violation?

            return repo.repo_name

    return None

def action_logger(user, action, repo, ipaddr='', sa=None, commit=False):

    """

    Action logger for various actions made by users

    :param user: user that made this action, can be a unique username string or

        object containing user_id attribute

    :param action: action to log, should be on of predefined unique actions for

        easy translations

    :param repo: string name of repository or object containing repo_id,

        that action was made on

    :param ipaddr: optional ip address from what the action was made

    :param sa: optional sqlalchemy session

    """

    if not sa:

        sa = meta.Session()

    # if we don't get explicit IP address try to get one from registered user

    # in tmpl context var

    if not ipaddr:

        ipaddr = getattr(get_current_authuser(), 'ip_addr', '')

    if getattr(user, 'user_id', None):

        user_obj = User.get(user.user_id)

    elif isinstance(user, basestring):

        user_obj = User.get_by_username(user)

    else:

        raise Exception('You have to provide a user object or a username')

    if getattr(repo, 'repo_id', None):

        repo_obj = Repository.get(repo.repo_id)

        repo_name = repo_obj.repo_name

    elif isinstance(repo, basestring):

        repo_name = repo.lstrip('/')

        repo_obj = Repository.get_by_repo_name(repo_name)

    else:

        repo_obj = None

        repo_name = ''

    user_log = UserLog()

    user_log.user_id = user_obj.user_id

    user_log.username = user_obj.username

    user_log.action = safe_unicode(action)

    user_log.repository = repo_obj

    user_log.repository_name = repo_name

    user_log.action_date = datetime.datetime.now()

    user_log.user_ip = ipaddr

    sa.add(user_log)

    log.info('Logging action:%s on %s by user:%s ip:%s' %

             (action, safe_unicode(repo), user_obj, ipaddr))

    if commit:

        sa.commit()

def get_filesystem_repos(path, recursive=False, skip_removed_repos=True):

    """

    Scans given path for repos and return (name,(type,path)) tuple

    :param path: path to scan for repositories

    :param recursive: recursive search and return names with subdirs in front

    """

    # remove ending slash for better results

    path = path.rstrip(os.sep)

    log.debug('now scanning in %s location recursive:%s...' % (path, recursive))

    def _get_repos(p):

        if not os.access(p, os.R_OK) or not os.access(p, os.X_OK):

            log.warning('ignoring repo path without access: %s' % (p,))

            return

        if not os.access(p, os.W_OK):

            log.warning('repo path without write access: %s' % (p,))

        for dirpath in os.listdir(p):

            if os.path.isfile(os.path.join(p, dirpath)):

                continue

            cur_path = os.path.join(p, dirpath)

            # skip removed repos

            if skip_removed_repos and REMOVED_REPO_PAT.match(dirpath):

                continue

            #skip .<somethin> dirs

            if dirpath.startswith('.'):

                continue

            try:

                scm_info = get_scm(cur_path)

                yield scm_info[1].split(path, 1)[-1].lstrip(os.sep), scm_info

            except VCSError:

                if not recursive:

                    continue

                #check if this dir containts other repos for recursive scan

                rec_path = os.path.join(p, dirpath)

                    for inner_scm in _get_repos(rec_path):

                        yield inner_scm

    return _get_repos(path)

def is_valid_repo(repo_name, base_path, scm=None):

    """

    Returns True if given path is a valid repository False otherwise.

    If scm param is given also compare if given scm is the same as expected

    from scm parameter

    :param repo_name:

    :param base_path:

    :param scm:

    :return True: if given path is a valid repository

    """

    full_path = os.path.join(safe_str(base_path), safe_str(repo_name))

    try:

        scm_ = get_scm(full_path)

        if scm:

            return scm_[0] == scm

        return True

    except VCSError:

        return False

def is_valid_repo_group(repo_group_name, base_path, skip_path_check=False):

    """

    Returns True if given path is a repository group False otherwise

    :param repo_name:

    :param base_path:

    """

    full_path = os.path.join(safe_str(base_path), safe_str(repo_group_name))

    # check if it's not a repo

    if is_valid_repo(repo_group_name, base_path):

        return False

    try:

        # we need to check bare git repos at higher level

        # since we might match branches/hooks/info/objects or possible

        # other things inside bare git repo

        get_scm(os.path.dirname(full_path))

        return False

    except VCSError:

        pass

    # check if it's a valid path

    if skip_path_check or os.path.isdir(full_path):

        return True

    return False

def ask_ok(prompt, retries=4, complaint='Yes or no please!'):

    while True:

        ok = raw_input(prompt)

        if ok in ('y', 'ye', 'yes'):

            return True

        if ok in ('n', 'no', 'nop', 'nope'):

            return False

        retries = retries - 1

        if retries < 0:

            raise IOError

        print complaint

#propagated from mercurial documentation

ui_sections = ['alias', 'auth',

                'decode/encode', 'defaults',

                'diff', 'email',

                'extensions', 'format',

                'merge-patterns', 'merge-tools',

                'hooks', 'http_proxy',

                'smtp', 'patch',

                'paths', 'profiling',

                'server', 'trusted',

                'ui', 'web', ]

def make_ui(read_from='file', path=None, checkpaths=True, clear_session=True):

    """

    A function that will read python rc files or database

    and make an mercurial ui object from read options

    :param path: path to mercurial config file

    :param checkpaths: check the path

    :param read_from: read from 'file' or 'db'

    """

    baseui = ui.ui()

    # clean the baseui object

    baseui._ocfg = config.config()

    baseui._ucfg = config.config()

    baseui._tcfg = config.config()

    if read_from == 'file':

        if not os.path.isfile(path):

            log.debug('hgrc file is not present at %s, skipping...' % path)

            return False

        log.debug('reading hgrc from %s' % path)

        cfg = config.config()

        cfg.read(path)

        for section in ui_sections:

            for k, v in cfg.items(section):

                log.debug('settings ui from file: [%s] %s=%s' % (section, k, v))

                baseui.setconfig(safe_str(section), safe_str(k), safe_str(v))

    elif read_from == 'db':

        sa = meta.Session()

        ret = sa.query(Ui).all()

        hg_ui = ret

        for ui_ in hg_ui:

            if ui_.ui_active:

                ui_val = safe_str(ui_.ui_value)

                if ui_.ui_section == 'hooks' and BRAND != 'kallithea' and ui_val.startswith('python:' + BRAND + '.lib.hooks.'):

                    ui_val = ui_val.replace('python:' + BRAND + '.lib.hooks.', 'python:kallithea.lib.hooks.')

                log.debug('settings ui from db: [%s] %s=%s', ui_.ui_section,

                          ui_.ui_key, ui_val)

                baseui.setconfig(safe_str(ui_.ui_section), safe_str(ui_.ui_key),

                                 ui_val)

            if ui_.ui_key == 'push_ssl':

                # force set push_ssl requirement to False, kallithea

                # handles that

                baseui.setconfig(safe_str(ui_.ui_section), safe_str(ui_.ui_key),

                                 False)

        if clear_session:

            meta.Session.remove()

        # prevent interactive questions for ssh password / passphrase

        ssh = baseui.config('ui', 'ssh', default='ssh')

        baseui.setconfig('ui', 'ssh', '%s -oBatchMode=yes -oIdentitiesOnly=yes' % ssh)

    return baseui

def set_app_settings(config):

    """

    Updates pylons config with new settings from database

    :param config:

    """

    hgsettings = Setting.get_app_settings()

    for k, v in hgsettings.items():

        config[k] = v

def set_vcs_config(config):

    """

    Patch VCS config with some Kallithea specific stuff

    :param config: kallithea.CONFIG

    """

    import kallithea

    from kallithea.lib.vcs import conf

    from kallithea.lib.utils2 import aslist

    conf.settings.BACKENDS = {

        'hg': 'kallithea.lib.vcs.backends.hg.MercurialRepository',

        'git': 'kallithea.lib.vcs.backends.git.GitRepository',

    }

    conf.settings.GIT_EXECUTABLE_PATH = config.get('git_path', 'git')

    conf.settings.GIT_REV_FILTER = config.get('git_rev_filter', '--all').strip()

    conf.settings.DEFAULT_ENCODINGS = aslist(config.get('default_encoding',

                                                        'utf8'), sep=',')

def map_groups(path):

    """

    Given a full path to a repository, create all nested groups that this

    repo is inside. This function creates parent-child relationships between

    groups and creates default perms for all new groups.

    :param paths: full path to repository

    """

    sa = meta.Session()

    groups = path.split(Repository.url_sep())

    parent = None

    group = None

    # last element is repo in nested groups structure

    groups = groups[:-1]

    rgm = RepoGroupModel(sa)

    owner = User.get_first_admin()

    for lvl, group_name in enumerate(groups):

        group_name = '/'.join(groups[:lvl] + [group_name])

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

# 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/>.

"""

kallithea.model.pull_request

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

pull request model for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Jun 6, 2012

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

import datetime

from pylons.i18n.translation import _

from kallithea.model.meta import Session

from kallithea.lib import helpers as h

from kallithea.model import BaseModel

from kallithea.model.db import PullRequest, PullRequestReviewers, Notification,\

    ChangesetStatus, User

from kallithea.model.notification import NotificationModel

from kallithea.lib.utils2 import extract_mentioned_users, safe_unicode

log = logging.getLogger(__name__)

class PullRequestModel(BaseModel):

    cls = PullRequest

    def __get_pull_request(self, pull_request):

        return self._get_instance(PullRequest, pull_request)

    def get_pullrequest_cnt_for_user(self, user):

        return PullRequest.query()\

                                .join(PullRequestReviewers)\

                                .filter(PullRequestReviewers.user_id == user)\

                                .filter(PullRequest.status != PullRequest.STATUS_CLOSED)\

                                .count()

    def get_all(self, repo_name, from_=False, closed=False):

        """Get all PRs for repo.

        Default is all PRs to the repo, PRs from the repo if from_.

        Closed PRs are only included if closed is true."""

        repo = self._get_repo(repo_name)

        q = PullRequest.query()

        if from_:

            q = q.filter(PullRequest.org_repo == repo)

        else:

            q = q.filter(PullRequest.other_repo == repo)

        if not closed:

            q = q.filter(PullRequest.status != PullRequest.STATUS_CLOSED)

        return q.order_by(PullRequest.created_on.desc()).all()

    def create(self, created_by, org_repo, org_ref, other_repo, other_ref,

               revisions, reviewers, title, description=None):

        from kallithea.model.changeset_status import ChangesetStatusModel

        created_by_user = self._get_user(created_by)

        org_repo = self._get_repo(org_repo)

        other_repo = self._get_repo(other_repo)

        new = PullRequest()

        new.org_repo = org_repo

        new.org_ref = org_ref

        new.other_repo = other_repo

        new.other_ref = other_ref

        new.revisions = revisions

        new.title = title

        new.description = description

        new.author = created_by_user

        Session().add(new)

        Session().flush()

        #reset state to under-review

        from kallithea.model.comment import ChangesetCommentsModel

        comment = ChangesetCommentsModel().create(

            text=u'Auto status change to %s' % (ChangesetStatus.get_status_lbl(ChangesetStatus.STATUS_UNDER_REVIEW)),

            repo=org_repo,

            user=new.author,

            pull_request=new,

            send_email=False

        )

        ChangesetStatusModel().set_status(

            org_repo,

            ChangesetStatus.STATUS_UNDER_REVIEW,

            new.author,

            comment,

            pull_request=new

        )

        mention_recipients = set(User.get_by_username(username, case_insensitive=True)

                                 for username in extract_mentioned_users(new.description))

        self.__add_reviewers(new, reviewers, mention_recipients)

        return new

    def __add_reviewers(self, pr, reviewers, mention_recipients=None):

        #members

        for member in set(reviewers):

            _usr = self._get_user(member)

            reviewer = PullRequestReviewers(_usr, pr)

            Session().add(reviewer)

        revision_data = [(x.raw_id, x.message)

                         for x in map(pr.org_repo.get_changeset, pr.revisions)]

        #notification to reviewers

        pr_url = pr.url(canonical=True)

        subject = safe_unicode(

            h.link_to(

              _('%(user)s wants you to review pull request %(pr_nice_id)s: %(pr_title)s') % \

                {'user': pr.author.username,

                 'pr_title': pr.title,

                 'pr_nice_id': pr.nice_id()},

                pr_url)

            )

        body = pr.description

        _org_ref_type, org_ref_name, _org_rev = pr.org_ref.split(':')

        email_kwargs = {

            'pr_title': pr.title,

            'pr_user_created': h.person(pr.author),

            'pr_repo_url': h.canonical_url('summary_home', repo_name=pr.other_repo.repo_name),

            'pr_url': pr_url,

            'pr_revisions': revision_data,

            'repo_name': pr.other_repo.repo_name,

            'pr_nice_id': pr.nice_id(),

            'ref': org_ref_name,

            'pr_username': pr.author.username,

            'threading': threading,

            'is_mention': False,

            }

        if reviewers:

            NotificationModel().create(created_by=pr.author, subject=subject, body=body,

                                       recipients=reviewers,

                                       type_=Notification.TYPE_PULL_REQUEST,

                                       email_kwargs=email_kwargs)

        if mention_recipients:

            mention_recipients.discard(None)

            mention_recipients.difference_update(reviewers)

        if mention_recipients:

            email_kwargs['is_mention'] = True

            subject = _('[Mention]') + ' ' + subject

            NotificationModel().create(created_by=pr.author, subject=subject, body=body,

                                       recipients=mention_recipients,

                                       type_=Notification.TYPE_PULL_REQUEST,

                                       email_kwargs=email_kwargs)

    def mention_from_description(self, pr, old_description=''):

        mention_recipients = set(User.get_by_username(username, case_insensitive=True)

                                 for username in extract_mentioned_users(pr.description))

        mention_recipients.difference_update(User.get_by_username(username, case_insensitive=True)

                                             for username in extract_mentioned_users(old_description))

        log.debug("Mentioning %s" % mention_recipients)

        self.__add_reviewers(pr, [], mention_recipients)

    def update_reviewers(self, pull_request, reviewers_ids):

        reviewers_ids = set(reviewers_ids)

        pull_request = self.__get_pull_request(pull_request)

        current_reviewers = PullRequestReviewers.query()\

                            .filter(PullRequestReviewers.pull_request==

                                   pull_request)\

                            .all()

        current_reviewers_ids = set([x.user.user_id for x in current_reviewers])

        to_add = reviewers_ids.difference(current_reviewers_ids)

        to_remove = current_reviewers_ids.difference(reviewers_ids)

        log.debug("Adding %s reviewers" % to_add)

        self.__add_reviewers(pull_request, to_add)

        log.debug("Removing %s reviewers" % to_remove)

        for uid in to_remove:

            reviewer = PullRequestReviewers.query()\

                    .filter(PullRequestReviewers.user_id==uid,

                            PullRequestReviewers.pull_request==pull_request)\

                    .scalar()

            if reviewer:

                Session().delete(reviewer)

    def delete(self, pull_request):

        pull_request = self.__get_pull_request(pull_request)

        Session().delete(pull_request)

    def close_pull_request(self, pull_request):

        pull_request = self.__get_pull_request(pull_request)

        pull_request.status = PullRequest.STATUS_CLOSED

        pull_request.updated_on = datetime.datetime.now()

        Session().add(pull_request)

                          <span class="booktag" title="${_('Bookmark %s') % book}">

                             ${h.link_to(book,h.url('changeset_home',repo_name=c.repo_name,revision=c.changeset.raw_id))}

                          </span>

                          %endfor

                        %endif

                        %for tag in c.changeset.tags:

                         <span class="tagtag"  title="${_('Tag %s') % tag}">

                         ${h.link_to(tag,h.url('changeset_home',repo_name=c.repo_name,revision=c.changeset.raw_id))}</span>

                        %endfor

                        %if c.changeset.branch:

                         <span class="branchtag" title="${_('Branch %s') % c.changeset.branch}">

                         ${h.link_to(c.changeset.branch,h.url('changelog_home',repo_name=c.repo_name,branch=c.changeset.branch))}

                         </span>

                        %endif

                    </span>

                </div>

                <div class="left">

                     <div class="author">

                         <div class="gravatar">

                           ${h.gravatar(h.email_or_none(c.changeset.author), size=20)}

                         </div>

                         <span><b>${h.person(c.changeset.author,'username_and_name')}</b> - ${h.age(c.changeset.date,True)} ${h.fmt_date(c.changeset.date)}</span><br/>

                         <span>${h.email_or_none(c.changeset.author)}</span><br/>

                     </div>

                     <% rev = c.changeset.extra.get('source') %>

                     %if rev:

                     <div>

                       ${_('Grafted from:')} ${h.link_to(h.short_id(rev),h.url('changeset_home',repo_name=c.repo_name,revision=rev))}

                     </div>

                     %endif

                     <% rev = c.changeset.extra.get('transplant_source', '').encode('hex') %>

                     %if rev:

                     <div>

                       ${_('Transplanted from:')} ${h.link_to(h.short_id(rev),h.url('changeset_home',repo_name=c.repo_name,revision=rev))}

                     </div>

                     %endif

                     <div class="message">${h.urlify_commit(c.changeset.message, c.repo_name)}</div>

                </div>

            </div>

            <div class="changes_txt">

            % if c.limited_diff:

            ${ungettext('%s file changed','%s files changed',len(c.changeset.affected_files)) % (len(c.changeset.affected_files))}:

            % else:

            ${ungettext('%s file changed with %s insertions and %s deletions','%s files changed with %s insertions and %s deletions', len(c.changeset.affected_files)) % (len(c.changeset.affected_files),c.lines_added,c.lines_deleted)}:

            %endif

            </div>

            <div class="cs_files">

              %for FID, (cs1, cs2, change, path, diff, stats) in c.changes[c.changeset.raw_id].iteritems():

                  <div class="cs_${change}">

                        <div class="node">

                            <i class="icon-diff-${change}"></i>

                            <a href="#${FID}">${h.safe_unicode(path)}</a>

                        </div>

                    <div class="changes">${h.fancy_file_stats(stats)}</div>

                  </div>

              %endfor

              % if c.limited_diff:

                <h5>${_('Changeset was too big and was cut off...')} <a href="${h.url.current(fulldiff=1, **request.GET.mixed())}">${_('Show full diff anyway')}</a></h5>

              % endif

            </div>

        </div>

    </div>

    ## diff block

    <%namespace name="diff_block" file="/changeset/diff_block.html"/>

    ${diff_block.diff_block_js()}

    ${diff_block.diff_block(c.changes[c.changeset.raw_id])}

    % if c.limited_diff:

      <h4>${_('Changeset was too big and was cut off...')} <a href="${h.url.current(fulldiff=1, **request.GET.mixed())}">${_('Show full diff anyway')}</a></h4>

    % endif

    ## template for inline comment form

    ${comment.comment_inline_form()}

    ## render comments and inlines

    ${comment.generate_comments()}

    ## main comment form and it status

    ${comment.comments(h.url('changeset_comment', repo_name=c.repo_name, revision=c.changeset.raw_id),

                       h.changeset_status(c.db_repo, c.changeset.raw_id))}

    ## FORM FOR MAKING JS ACTION AS CHANGESET COMMENTS

    <script type="text/javascript">

      $(document).ready(function(){

          $('.show-inline-comments').change(function(e){

              var target = e.currentTarget;

              if(target == null){

                  target = this;

              }

              var boxid = $(target).attr('id_for');

              if(target.checked){

                  $('#{0} .inline-comments'.format(boxid)).show();

                  $('#{0} .inline-comments-button'.format(boxid)).show();

              }else{

                  $('#{0} .inline-comments'.format(boxid)).hide();

                  $('#{0} .inline-comments-button'.format(boxid)).hide();

              }

          });

          $('.add-bubble').click(function(e){

              var tr = e.currentTarget;

              if(tr == null){

                  tr = this;

              }

              injectInlineForm(tr.parentNode.parentNode);

          });

          // inject comments into they proper positions

          var file_comments = $('.inline-comment-placeholder').toArray();

          renderInlineComments(file_comments);

          linkInlineComments(document.getElementsByClassName('firstlink'), document.getElementsByClassName("comment"));

          pyroutes.register('changeset_home',

                            "${h.url('changeset_home', repo_name='%(repo_name)s', revision='%(revision)s')}",

                            ['repo_name', 'revision']);

          //next links

          $('#child_link').on('click', function(e){

              //fetch via ajax what is going to be the next link, if we have

              //>1 links show them to user to choose

              if(!$('#child_link').hasClass('disabled')){

                  $.ajax({

                    url: '${h.url('changeset_children',repo_name=c.repo_name, revision=c.changeset.raw_id)}',

                    success: function(data) {

                      if(data.results.length === 0){

                          $('#child_link').addClass('disabled');

                          $('#child_link').html('${_('no revisions')}');

                      }

                      if(data.results.length === 1){

                          var commit = data.results[0];

                          window.location = pyroutes.url('changeset_home', {'repo_name': '${c.repo_name}','revision': commit.raw_id});

                      }

                      else if(data.results.length === 2){

                          $('#child_link').addClass('disabled');

                          $('#child_link').addClass('double');

                          var _html = '';

                          _html +='<a title="__title__" href="__url__">__rev__</a> <i style="color:#036185" class="icon-right-open"></i>'

                                  .replace('__rev__','r{0}:{1}'.format(data.results[0].revision, data.results[0].raw_id.substr(0,6)))

                                  .replace('__title__', data.results[0].message)

                                  .replace('__url__', pyroutes.url('changeset_home', {'repo_name': '${c.repo_name}','revision': data.results[0].raw_id}));

                          _html +='<br/>'

                          _html +='<a title="__title__" href="__url__">__rev__</a> <i style="color:#036185" class="icon-right-open"></i>'

                                  .replace('__rev__','r{0}:{1}'.format(data.results[1].revision, data.results[1].raw_id.substr(0,6)))

                                  .replace('__title__', data.results[1].message)

                                  .replace('__url__', pyroutes.url('changeset_home', {'repo_name': '${c.repo_name}','revision': data.results[1].raw_id}));

                          $('#child_link').html(_html);

                      }

                    }

                  });

              e.preventDefault();

              }

          })

          //prev links

          $('#parent_link').on('click', function(e){

              //fetch via ajax what is going to be the next link, if we have

              //>1 links show them to user to choose

              if(!$('#parent_link').hasClass('disabled')){

                  $.ajax({

                    url: '${h.url('changeset_parents',repo_name=c.repo_name, revision=c.changeset.raw_id)}',

                    success: function(data) {

                      if(data.results.length === 0){

                          $('#parent_link').addClass('disabled');

                          $('#parent_link').html('${_('no revisions')}');

                      }

                      if(data.results.length === 1){

                          var commit = data.results[0];

                          window.location = pyroutes.url('changeset_home', {'repo_name': '${c.repo_name}','revision': commit.raw_id});

                      }

                      else if(data.results.length === 2){

                          $('#parent_link').addClass('disabled');

                          $('#parent_link').addClass('double');

                          var _html = '';

                          _html +='<i style="color:#036185" class="icon-left-open"></i> <a title="__title__" href="__url__">__rev__</a>'

                                  .replace('__rev__','r{0}:{1}'.format(data.results[0].revision, data.results[0].raw_id.substr(0,6)))

                                  .replace('__title__', data.results[0].message)

                                  .replace('__url__', pyroutes.url('changeset_home', {'repo_name': '${c.repo_name}','revision': data.results[0].raw_id}));

                          _html +='<br/>'

                          _html +='<i style="color:#036185" class="icon-left-open"></i> <a title="__title__" href="__url__">__rev__</a>'

                                  .replace('__rev__','r{0}:{1}'.format(data.results[1].revision, data.results[1].raw_id.substr(0,6)))

                                  .replace('__title__', data.results[1].message)

                                  .replace('__url__', pyroutes.url('changeset_home', {'repo_name': '${c.repo_name}','revision': data.results[1].raw_id}));

                          $('#parent_link').html(_html);

                      }

                    }

                  });

              e.preventDefault();

              }

      })

    </script>

    </div>

</%def>

pyroutes.register('files_nodelist_home', "${h.url('files_nodelist_home', repo_name=c.repo_name,revision='%(revision)s',f_path='%(f_path)s')}", ['revision', 'f_path']);

pyroutes.register('files_history_home', "${h.url('files_history_home', repo_name=c.repo_name,revision='%(revision)s',f_path='%(f_path)s')}", ['revision', 'f_path']);

pyroutes.register('files_authors_home', "${h.url('files_authors_home', repo_name=c.repo_name,revision='%(revision)s',f_path='%(f_path)s')}", ['revision', 'f_path']);

var ypjax_links = function(){

    $('.ypjax-link').click(function(e){

        //don't do ypjax on middle click

        if(e.which == 2 || !History.enabled){

            return true;

        }

        var el = e.currentTarget;

        var url = el.href;

        var _base_url = '${h.url("files_home",repo_name=c.repo_name,revision='',f_path='')}';

        _base_url = _base_url.replace('//','/')

        //extract rev and the f_path from url.

        parts = url.split(_base_url)

        if(parts.length != 2){

            return false;

        }

        var parts2 = parts[1].split('/');

        var rev = parts2.shift(); // pop the first element which is the revision

        var f_path = parts2.join('/');

        //page title - make this consistent with title mako block above

        var title = "${_('%s Files') % c.repo_name}" + " \u00B7 " + (f_path || '/') + " \u00B7 " + "${c.site_name}";

        var _node_list_url = node_list_url.replace('__REV__',rev).replace('__FPATH__', f_path);

        var _url_base = url_base.replace('__REV__',rev);

        // Change our States and save some data for handling events

        var data = {url:url,title:title, url_base:_url_base,

                    node_list_url:_node_list_url, rev:rev, f_path:f_path};

        History.pushState(data, title, url);

        //now we're sure that we can do ypjax things

        e.preventDefault();

        return false;

    });

}

// callbacks needed to process the ypjax filebrowser

var callbacks = function(State){

    ypjax_links();

    tooltip_activate();

    if(State !== undefined){

        //inistially loaded stuff

        var _f_path = State.data.f_path;

        var _rev = State.data.rev;

        fileBrowserListeners(State.url, State.data.node_list_url, State.data.url_base);

        // Inform Google Analytics of the change

        if ( typeof window.pageTracker !== 'undefined' ) {