# -*- 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.controllers.files

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

Files controller 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: Apr 21, 2010

:author: marcink

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

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

"""

from __future__ import with_statement

import os

import logging

import traceback

import tempfile

import shutil

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

from pylons.i18n.translation import _

from pylons.controllers.util import redirect

from kallithea.lib.utils import jsonify, action_logger

from kallithea.lib import diffs

from kallithea.lib import helpers as h

from kallithea.lib.compat import OrderedDict

from kallithea.lib.utils2 import convert_line_endings, detect_mode, safe_str,\

    str2bool

from kallithea.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from kallithea.lib.base import BaseRepoController, render

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

from kallithea.lib.vcs.conf import settings

from kallithea.lib.vcs.exceptions import RepositoryError, \

    ChangesetDoesNotExistError, EmptyRepositoryError, \

    ImproperArchiveTypeError, VCSError, NodeAlreadyExistsError,\

    NodeDoesNotExistError, ChangesetError, NodeError

from kallithea.lib.vcs.nodes import FileNode

from kallithea.model.repo import RepoModel

from kallithea.model.scm import ScmModel

from kallithea.model.db import Repository

from kallithea.controllers.changeset import anchor_url, _ignorews_url,\

    _context_url, get_line_ctx, get_ignore_ws

from webob.exc import HTTPNotFound

from kallithea.lib.exceptions import NonRelativePathError

log = logging.getLogger(__name__)

class FilesController(BaseRepoController):

    def __before__(self):

        super(FilesController, self).__before__()

        c.cut_off_limit = self.cut_off_limit

    def __get_cs(self, rev, silent_empty=False):

        """

        Safe way to get changeset if error occur it redirects to tip with

        proper message

        :param rev: revision to fetch

        :silent_empty: return None if repository is empty

        """

        try:

            return c.db_repo_scm_instance.get_changeset(rev)

        except EmptyRepositoryError, e:

            if silent_empty:

                return None

            url_ = url('files_add_home',

                       repo_name=c.repo_name,

                       revision=0, f_path='', anchor='edit')

            add_new = h.link_to(_('Click here to add new file'), url_, class_="alert-link")

            h.flash(h.literal(_('There are no files yet. %s') % add_new),

                    category='warning')

            raise HTTPNotFound()

        except(ChangesetDoesNotExistError, LookupError), e:

            msg = _('Such revision does not exist for this repository')

            h.flash(msg, category='error')

            raise HTTPNotFound()

        except RepositoryError, e:

            h.flash(safe_str(e), category='error')

            raise HTTPNotFound()

    def __get_filenode(self, cs, path):

        """

        Returns file_node or raise HTTP error.

        :param cs: given changeset

        :param path: path to lookup

        """

        try:

            file_node = cs.get_node(path)

            if file_node.is_dir():

                raise RepositoryError('given path is a directory')

        except(ChangesetDoesNotExistError,), e:

            msg = _('Such revision does not exist for this repository')

            h.flash(msg, category='error')

            raise HTTPNotFound()

        except RepositoryError, e:

            h.flash(safe_str(e), category='error')

            raise HTTPNotFound()

        return file_node

    @LoginRequired()

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

                                   'repository.admin')

    def index(self, repo_name, revision, f_path, annotate=False):

        # redirect to given revision from form if given

        post_revision = request.POST.get('at_rev', None)

        if post_revision:

            cs = self.__get_cs(post_revision) # FIXME - unused!

        c.revision = revision

        c.changeset = self.__get_cs(revision)

        c.branch = request.GET.get('branch', None)

        c.f_path = f_path

        c.annotate = annotate

        cur_rev = c.changeset.revision

        # prev link

        try:

            prev_rev = c.db_repo_scm_instance.get_changeset(cur_rev).prev(c.branch)

            c.url_prev = url('files_home', repo_name=c.repo_name,

                         revision=prev_rev.raw_id, f_path=f_path)

            if c.branch:

                c.url_prev += '?branch=%s' % c.branch

        except (ChangesetDoesNotExistError, VCSError):

            c.url_prev = '#'

        # next link

        try:

            next_rev = c.db_repo_scm_instance.get_changeset(cur_rev).next(c.branch)

            c.url_next = url('files_home', repo_name=c.repo_name,

                     revision=next_rev.raw_id, f_path=f_path)

            if c.branch:

                c.url_next += '?branch=%s' % c.branch

        except (ChangesetDoesNotExistError, VCSError):

            c.url_next = '#'

        # files or dirs

        try:

            c.file = c.changeset.get_node(f_path)

            if c.file.is_file():

                c.load_full_history = False

                file_last_cs = c.file.last_changeset

                c.file_changeset = (c.changeset

                                    if c.changeset.revision < file_last_cs.revision

                                    else file_last_cs)

                #determine if we're on branch head

                _branches = c.db_repo_scm_instance.branches

                c.on_branch_head = revision in _branches.keys() + _branches.values()

                _hist = []

                c.file_history = []

                if c.load_full_history:

                    c.file_history, _hist = self._get_node_history(c.changeset, f_path)

                c.authors = []

                for a in set([x.author for x in _hist]):

                    c.authors.append((h.email(a), h.person(a)))

            else:

                c.authors = c.file_history = []

        except RepositoryError, e:

            h.flash(safe_str(e), category='error')

            raise HTTPNotFound()

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

            return render('files/files_ypjax.html')

        return render('files/files.html')

    @LoginRequired()

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

                                   'repository.admin')

    @jsonify

    def history(self, repo_name, revision, f_path):

        changeset = self.__get_cs(revision)

        f_path = f_path

        _file = changeset.get_node(f_path)

        if _file.is_file():

            file_history, _hist = self._get_node_history(changeset, f_path)

            res = []

            for obj in file_history:

                res.append({

                    'text': obj[1],

                    'children': [{'id': o[0], 'text': o[1]} for o in obj[0]]

                })

            data = {

                'more': False,

                'results': res

            }

            return data

    @LoginRequired()

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

                                   'repository.admin')

    def authors(self, repo_name, revision, f_path):

        changeset = self.__get_cs(revision)

        f_path = f_path

        _file = changeset.get_node(f_path)

        if _file.is_file():

            file_history, _hist = self._get_node_history(changeset, f_path)

            c.authors = []

            for a in set([x.author for x in _hist]):

                c.authors.append((h.email(a), h.person(a)))

            return render('files/files_history_box.html')

    @LoginRequired()

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

                                   'repository.admin')

    def rawfile(self, repo_name, revision, f_path):

        cs = self.__get_cs(revision)

        file_node = self.__get_filenode(cs, f_path)

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

            safe_str(f_path.split(Repository.url_sep())[-1])

        response.content_type = file_node.mimetype

        return file_node.content

    @LoginRequired()

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

                                   'repository.admin')

    def raw(self, repo_name, revision, f_path):

        cs = self.__get_cs(revision)

        file_node = self.__get_filenode(cs, f_path)

        raw_mimetype_mapping = {

            # map original mimetype to a mimetype used for "show as raw"

            # you can also provide a content-disposition to override the

            # default "attachment" disposition.

            # orig_type: (new_type, new_dispo)

            # show images inline:

            'image/x-icon': ('image/x-icon', 'inline'),

            'image/png': ('image/png', 'inline'),

            'image/gif': ('image/gif', 'inline'),

            'image/jpeg': ('image/jpeg', 'inline'),

            'image/svg+xml': ('image/svg+xml', 'inline'),

        }

        mimetype = file_node.mimetype

        try:

            mimetype, dispo = raw_mimetype_mapping[mimetype]

        except KeyError:

            # we don't know anything special about this, handle it safely

            if file_node.is_binary:

                # do same as download raw for binary files

                mimetype, dispo = 'application/octet-stream', 'attachment'

            else:

                # do not just use the original mimetype, but force text/plain,

                # otherwise it would serve text/html and that might be unsafe.

                # Note: underlying vcs library fakes text/plain mimetype if the

                # mimetype can not be determined and it thinks it is not

                # binary.This might lead to erroneous text display in some

                # cases, but helps in other cases, like with text files

                # without extension.

                mimetype, dispo = 'text/plain', 'inline'

        if dispo == 'attachment':

            dispo = 'attachment; filename=%s' % \

                        safe_str(f_path.split(os.sep)[-1])

        response.content_disposition = dispo

        response.content_type = mimetype

        return file_node.content

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')

    def delete(self, repo_name, revision, f_path):

        repo = c.db_repo

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

            h.flash(_('This repository is has been locked by %s on %s')

                % (h.person_by_id(repo.locked[0]),

                   h.fmt_date(h.time_to_datetime(repo.locked[1]))),

                'warning')

            return redirect(h.url('files_home',

                                  repo_name=repo_name, revision='tip'))

        # check if revision is a branch identifier- basically we cannot

        # create multiple heads via file editing

        _branches = repo.scm_instance.branches

        # check if revision is a branch name or branch hash

        if revision not in _branches.keys() + _branches.values():

            h.flash(_('You can only delete files with revision '

                      'being a valid branch '), category='warning')

            return redirect(h.url('files_home',

                                  repo_name=repo_name, revision='tip',

                                  f_path=f_path))

        r_post = request.POST

        c.cs = self.__get_cs(revision)

        c.file = self.__get_filenode(c.cs, f_path)

        c.default_message = _('Deleted file %s via Kallithea') % (f_path)

        c.f_path = f_path

        node_path = f_path

        author = self.authuser.full_contact

        if r_post:

            message = r_post.get('message') or c.default_message

            try:

                nodes = {

                    node_path: {

                        'content': ''

                    }

                }

                self.scm_model.delete_nodes(

                    user=c.authuser.user_id, repo=c.db_repo,

                    message=message,

                    nodes=nodes,

                    parent_cs=c.cs,

                    author=author,

                )

                h.flash(_('Successfully deleted file %s') % f_path,

                        category='success')

            except Exception:

                log.error(traceback.format_exc())

                h.flash(_('Error occurred during commit'), category='error')

            return redirect(url('changeset_home',

                                repo_name=c.repo_name, revision='tip'))

        return render('files/files_delete.html')

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')

    def edit(self, repo_name, revision, f_path):

        repo = c.db_repo

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

            h.flash(_('This repository is has been locked by %s on %s')

                % (h.person_by_id(repo.locked[0]),

                   h.fmt_date(h.time_to_datetime(repo.locked[1]))),

                'warning')

            return redirect(h.url('files_home',

                                  repo_name=repo_name, revision='tip'))

        # check if revision is a branch identifier- basically we cannot

        # create multiple heads via file editing

        _branches = repo.scm_instance.branches

        # check if revision is a branch name or branch hash

        if revision not in _branches.keys() + _branches.values():

            h.flash(_('You can only edit files with revision '

                      'being a valid branch '), category='warning')

            return redirect(h.url('files_home',

                                  repo_name=repo_name, revision='tip',

                                  f_path=f_path))

        r_post = request.POST

        c.cs = self.__get_cs(revision)

        c.file = self.__get_filenode(c.cs, f_path)

        if c.file.is_binary:

            return redirect(url('files_home', repo_name=c.repo_name,

                            revision=c.cs.raw_id, f_path=f_path))

        c.default_message = _('Edited file %s via Kallithea') % (f_path)

<%inherit file="/base/base.html"/>

<%def name="title(*args)">

    ${_('%s Files') % c.repo_name}

    %if hasattr(c,'file'):

        · ${h.safe_unicode(c.file.path) or '\\'}

    %endif

    %if c.site_name:

        · ${c.site_name}

    %endif

</%def>

<%def name="breadcrumbs_links()">

    ${_('Files')}

    %if c.file:

        @ ${h.show_id(c.changeset)}

    %endif

</%def>

<%def name="page_nav()">

    ${self.menu('repositories')}

</%def>

<%def name="main()">

${self.repo_context_bar('files', c.revision)}

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}

        <ul class="links">

            </li>

        </ul>

    </div>

    <div class="table">

        <div id="files_data">

            <%include file='files_ypjax.html'/>

        </div>

    </div>

</div>

<script type="text/javascript">

var CACHE = {};

var CACHE_EXPIRE = 5*60*1000; //cache for 5*60s

//used to construct links from the search list

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

//send the nodelist request to this url

var node_list_url = '${h.url("files_nodelist_home",repo_name=c.repo_name,revision='__REV__',f_path='__FPATH__')}';

// send the node history requst to this url

var node_history_url = '${h.url("files_history_home",repo_name=c.repo_name,revision='__REV__',f_path='__FPATH__')}';

## new pyroutes URLs

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(){

    YUE.on(YUQ('.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 function on top

        var title = "${_('%s Files') % c.repo_name}" + " · " + (f_path || '\\') + " · " + "${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

        YUE.preventDefault(e);

        return false;

    });

}

// callbacks needed to process the pjax 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' ) {

            window.pageTracker._trackPageview(State.url);

        }

    }

    function highlight_lines(lines){

        for(pos in lines){

          YUD.setStyle('L'+lines[pos],'background-color','#FFFFBE');

        }

    }

    page_highlights = location.href.substring(location.href.indexOf('#')+1).split('L');

    if (page_highlights.length == 2){

       highlight_ranges  = page_highlights[1].split(",");

       var h_lines = [];

       for (pos in highlight_ranges){

            var _range = highlight_ranges[pos].split('-');

            if(_range.length == 2){

                var start = parseInt(_range[0]);

                var end = parseInt(_range[1]);

                if (start < end){

                    for(var i=start;i<=end;i++){

                        h_lines.push(i);

                    }

                }

            }

            else{

                h_lines.push(parseInt(highlight_ranges[pos]));

            }

      }

      highlight_lines(h_lines);

      var _first_line= YUD.get('L'+h_lines[0]);

      if(_first_line){

          _first_line.scrollIntoView()

      }

    }

    // select code link event

    YUE.on('hlcode', 'mouseup', getSelectionLink);

    // history select field

    var cache = {}

    $("#diff1").select2({

        placeholder: _TM['Select changeset'],

        dropdownAutoWidth: true,

        query: function(query){

          var key = 'cache';

          var cached = cache[key] ;

          if(cached) {

            var data = {results: []};

            //filter results

            $.each(cached.results, function(){

                var section = this.text;

                var children = [];

                $.each(this.children, function(){

                    if(query.term.length == 0 || this.text.toUpperCase().indexOf(query.term.toUpperCase()) >= 0 ){

                        children.push({'id': this.id, 'text': this.text})

                    }

                })

                data.results.push({'text': section, 'children': children})

            });

            query.callback(data);

          }else{

              $.ajax({

                url: pyroutes.url('files_history_home', {'revision': _rev, 'f_path': _f_path}),

                data: {},

                dataType: 'json',

                type: 'GET',

                success: function(data) {

                  cache[key] = data;

                  query.callback({results: data.results});

                }

              })

          }

        },

    });

    $('#show_authors').on('click', function(){

        $.ajax({

            url: pyroutes.url('files_authors_home', {'revision': _rev, 'f_path': _f_path}),

            success: function(data) {

                $('#file_authors').html(data);

                $('#file_authors').show();

                tooltip_activate()

            }

        })

    })

}

$(document).ready(function(){

    ypjax_links();

    var container = 'files_data';

    //Bind to StateChange Event

    History.Adapter.bind(window,'statechange',function(){

        var State = History.getState();

        cache_key = State.url;

        //check if we have this request in cache maybe ?

        var _cache_obj = CACHE[cache_key];

        var _cur_time = new Date().getTime();

        // get from cache if it's there and not yet expired !

        if(_cache_obj !== undefined && _cache_obj[0] > _cur_time){

            YUD.get(container).innerHTML=_cache_obj[1];

            YUD.setStyle(container,'opacity','1.0');

            //callbacks after ypjax call

            callbacks(State);

        }

        else{

          ypjax(State.url,container,function(o){

              //callbacks after ypjax call

              callbacks(State);

              if (o !== undefined){

                //store our request in cache

                var _expire_on = new Date().getTime()+CACHE_EXPIRE;

              CACHE[cache_key] = [_expire_on, o.responseText];

            }

          });

        }

    });

    // init the search filter

    var _State = {

       url: "${h.url.current()}",

       data: {

         node_list_url: node_list_url.replace('__REV__',"${c.changeset.raw_id}").replace('__FPATH__', "${h.safe_unicode(c.file.path)}"),

         url_base: url_base.replace('__REV__',"${c.changeset.raw_id}"),

         rev:"${c.changeset.raw_id}",

         f_path: "${h.safe_unicode(c.file.path)}"

       }

    }

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

});

</script>

</%def>

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

import os

from kallithea.tests import *

from kallithea.model.db import Repository

from kallithea.model.meta import Session

from kallithea.tests.fixture import Fixture

fixture = Fixture()

ARCHIVE_SPECS = {

    '.tar.bz2': ('application/x-bzip2', 'tbz2', ''),

    '.tar.gz': ('application/x-gzip', 'tgz', ''),

    '.zip': ('application/zip', 'zip', ''),

}

HG_NODE_HISTORY = fixture.load_resource('hg_node_history_response.json')

GIT_NODE_HISTORY = fixture.load_resource('git_node_history_response.json')

def _set_downloads(repo_name, set_to):

    repo = Repository.get_by_repo_name(repo_name)

    repo.enable_downloads = set_to

    Session().add(repo)

    Session().commit()

class TestFilesController(TestController):

    def test_index(self):

        self.log_user()

        response = self.app.get(url(controller='files', action='index',

                                    repo_name=HG_REPO,

                                    revision='tip',

                                    f_path='/'))

        # Test response...

        response.mustcontain('<a class="browser-dir ypjax-link" href="/vcs_test_hg/files/96507bd11ecc815ebc6270fdf6db110928c09c1e/docs">docs</a>')

        response.mustcontain('<a class="browser-dir ypjax-link" href="/vcs_test_hg/files/96507bd11ecc815ebc6270fdf6db110928c09c1e/vcs">vcs</a>')

        response.mustcontain('<a class="browser-file ypjax-link" href="/vcs_test_hg/files/96507bd11ecc815ebc6270fdf6db110928c09c1e/.gitignore">.gitignore</a>')

        response.mustcontain('<a class="browser-file ypjax-link" href="/vcs_test_hg/files/96507bd11ecc815ebc6270fdf6db110928c09c1e/.hgignore">.hgignore</a>')

        response.mustcontain('<a class="browser-file ypjax-link" href="/vcs_test_hg/files/96507bd11ecc815ebc6270fdf6db110928c09c1e/.hgtags">.hgtags</a>')

        response.mustcontain('<a class="browser-file ypjax-link" href="/vcs_test_hg/files/96507bd11ecc815ebc6270fdf6db110928c09c1e/.travis.yml">.travis.yml</a>')

        response.mustcontain('<a class="browser-file ypjax-link" href="/vcs_test_hg/files/96507bd11ecc815ebc6270fdf6db110928c09c1e/MANIFEST.in">MANIFEST.in</a>')

        response.mustcontain('<a class="browser-file ypjax-link" href="/vcs_test_hg/files/96507bd11ecc815ebc6270fdf6db110928c09c1e/README.rst">README.rst</a>')

        response.mustcontain('<a class="browser-file ypjax-link" href="/vcs_test_hg/files/96507bd11ecc815ebc6270fdf6db110928c09c1e/run_test_and_report.sh">run_test_and_report.sh</a>')

        response.mustcontain('<a class="browser-file ypjax-link" href="/vcs_test_hg/files/96507bd11ecc815ebc6270fdf6db110928c09c1e/setup.cfg">setup.cfg</a>')

        response.mustcontain('<a class="browser-file ypjax-link" href="/vcs_test_hg/files/96507bd11ecc815ebc6270fdf6db110928c09c1e/setup.py">setup.py</a>')

        response.mustcontain('<a class="browser-file ypjax-link" href="/vcs_test_hg/files/96507bd11ecc815ebc6270fdf6db110928c09c1e/test_and_report.sh">test_and_report.sh</a>')

        response.mustcontain('<a class="browser-file ypjax-link" href="/vcs_test_hg/files/96507bd11ecc815ebc6270fdf6db110928c09c1e/tox.ini">tox.ini</a>')

    def test_index_revision(self):

        self.log_user()

        response = self.app.get(

            url(controller='files', action='index',

                repo_name=HG_REPO,

                revision='7ba66bec8d6dbba14a2155be32408c435c5f4492',

                f_path='/')

        )

        #Test response...

        response.mustcontain('<a class="browser-dir ypjax-link" href="/vcs_test_hg/files/7ba66bec8d6dbba14a2155be32408c435c5f4492/docs">docs</a>')

        response.mustcontain('<a class="browser-dir ypjax-link" href="/vcs_test_hg/files/7ba66bec8d6dbba14a2155be32408c435c5f4492/tests">tests</a>')

        response.mustcontain('<a class="browser-file ypjax-link" href="/vcs_test_hg/files/7ba66bec8d6dbba14a2155be32408c435c5f4492/README.rst">README.rst</a>')

        response.mustcontain('1.1 KiB')

        response.mustcontain('text/x-python')

    def test_index_different_branch(self):

        self.log_user()

        response = self.app.get(url(controller='files', action='index',

                                    repo_name=HG_REPO,

                                    revision='97e8b885c04894463c51898e14387d80c30ed1ee',

                                    f_path='/'))

    def test_index_paging(self):

        self.log_user()

        for r in [(73, 'a066b25d5df7016b45a41b7e2a78c33b57adc235'),

                  (92, 'cc66b61b8455b264a7a8a2d8ddc80fcfc58c221e'),

                  (109, '75feb4c33e81186c87eac740cee2447330288412'),

                  (1, '3d8f361e72ab303da48d799ff1ac40d5ac37c67e'),

                  (0, 'b986218ba1c9b0d6a259fac9b050b1724ed8e545')]:

            response = self.app.get(url(controller='files', action='index',

                                    repo_name=HG_REPO,

                                    revision=r[1],

                                    f_path='/'))

            response.mustcontain("""@ r%s:%s""" % (r[0], r[1][:12]))

    def test_file_source(self):

        self.log_user()

        response = self.app.get(url(controller='files', action='index',

                                    repo_name=HG_REPO,

                                    revision='8911406ad776fdd3d0b9932a2e89677e57405a48',

                                    f_path='vcs/nodes.py'))

        response.mustcontain("""<div class="commit">Partially implemented <a class="issue-tracker-link" href="https://myissueserver.com/vcs_test_hg/issue/16">#16</a>. filecontent/commit message/author/node name are safe_unicode now.

In addition some other __str__ are unicode as well

Added test for unicode

Improved test to clone into uniq repository.

removed extra unicode conversion in diff.</div>

""")

    def test_file_source_history(self):

        self.log_user()

        response = self.app.get(url(controller='files', action='history',

                                    repo_name=HG_REPO,

                                    revision='tip',

                                    f_path='vcs/nodes.py'),

                                extra_environ={'HTTP_X_PARTIAL_XHR': '1'},)

        self.assertEqual(response.body, HG_NODE_HISTORY)

    def test_file_source_history_git(self):

        self.log_user()

        response = self.app.get(url(controller='files', action='history',

                                    repo_name=GIT_REPO,

                                    revision='master',

                                    f_path='vcs/nodes.py'),

                                extra_environ={'HTTP_X_PARTIAL_XHR': '1'},)

        self.assertEqual(response.body, GIT_NODE_HISTORY)

    def test_file_annotation(self):

        self.log_user()

        response = self.app.get(url(controller='files', action='index',

                                    repo_name=HG_REPO,

                                    revision='tip',

                                    f_path='vcs/nodes.py',

                                    annotate=True))

        response.mustcontain("""r356:25213a5fbb04""")

    def test_file_annotation_git(self):

        self.log_user()

        response = self.app.get(url(controller='files', action='index',

                                    repo_name=GIT_REPO,

                                    revision='master',

                                    f_path='vcs/nodes.py',

                                    annotate=True))

        response.mustcontain("""r345:c994f0de03b2""")

    def test_file_annotation_history(self):

        self.log_user()

        response = self.app.get(url(controller='files', action='history',

                                    repo_name=HG_REPO,

                                    revision='tip',

                                    f_path='vcs/nodes.py',

                                    annotate=True),

                                extra_environ={'HTTP_X_PARTIAL_XHR': '1'})

        self.assertEqual(response.body, HG_NODE_HISTORY)

    def test_file_annotation_history_git(self):

        self.log_user()

        response = self.app.get(url(controller='files', action='history',

                                    repo_name=GIT_REPO,

                                    revision='master',

                                    f_path='vcs/nodes.py',

                                    annotate=True),

                                extra_environ={'HTTP_X_PARTIAL_XHR': '1'})

        self.assertEqual(response.body, GIT_NODE_HISTORY)

    def test_file_authors(self):

        self.log_user()

        response = self.app.get(url(controller='files', action='authors',

                                    repo_name=HG_REPO,

                                    revision='tip',

                                    f_path='vcs/nodes.py',

                                    annotate=True))

        response.mustcontain('Marcin Kuzminski')

        response.mustcontain('Lukasz Balcerzak')

    def test_file_authors_git(self):

        self.log_user()

        response = self.app.get(url(controller='files', action='authors',

                                    repo_name=GIT_REPO,

                                    revision='master',

                                    f_path='vcs/nodes.py',

                                    annotate=True))

        response.mustcontain('Marcin Kuzminski')

        response.mustcontain('Lukasz Balcerzak')

    def test_archival(self):

        self.log_user()

        _set_downloads(HG_REPO, set_to=True)

        for arch_ext, info in ARCHIVE_SPECS.items():

            short = '27cd5cce30c9%s' % arch_ext

            fname = '27cd5cce30c96924232dffcd24178a07ffeb5dfc%s' % arch_ext

            filename = '%s-%s' % (HG_REPO, short)

            response = self.app.get(url(controller='files',

                                        action='archivefile',

                                        repo_name=HG_REPO,

                                        fname=fname))

            self.assertEqual(response.status, '200 OK')

            heads = [

                ('Pragma', 'no-cache'),

                ('Cache-Control', 'no-cache'),

                ('Content-Disposition', 'attachment; filename=%s' % filename),

                ('Content-Type', '%s; charset=utf-8' % info[0]),

            ]

            self.assertEqual(response.response._headers.items(), heads)