revision=revision))

        return render('files/files.html')

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

        cs = self.__get_cs_or_redirect(revision, repo_name)

        try:

            file_node = cs.get_node(f_path)

        except RepositoryError, e:

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

            redirect(h.url('files_home', repo_name=repo_name,

                           revision=cs.raw_id))

        fname = f_path.split(os.sep)[-1].encode('utf8', 'replace')

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

        response.content_type = file_node.mimetype

        return file_node.content

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

        cs = self.__get_cs_or_redirect(revision, repo_name)

        try:

            file_node = cs.get_node(f_path)

        except RepositoryError, e:

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

            redirect(h.url('files_home', repo_name=repo_name,

                           revision=cs.raw_id))

        response.content_type = 'text/plain'

        return file_node.content

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

        cs = self.__get_cs_or_redirect(revision, repo_name)

        try:

            c.file = cs.get_node(f_path)

        except RepositoryError, e:

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

            redirect(h.url('files_home', repo_name=repo_name, revision=cs.raw_id))

        c.file_history = self._get_history(ScmModel().get_repo(c.repo_name), c.file, f_path)

        c.cs = cs

        c.f_path = f_path

        return render('files/files_annotate.html')

    def archivefile(self, repo_name, revision, fileformat):

        archive_specs = {

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

        }

        if not archive_specs.has_key(fileformat):

            return 'Unknown archive type %s' % fileformat

        def read_in_chunks(file_object, chunk_size=1024 * 40):

            """Lazy function (generator) to read a file piece by piece.

            Default chunk size: 40k."""

            while True:

                data = file_object.read(chunk_size)

                if not data:

                    break

                yield data

        archive = tempfile.TemporaryFile()

        repo = ScmModel().get_repo(repo_name).repo

        fname = '%s-%s%s' % (repo_name, revision, fileformat)

        archival.archive(repo, archive, revision, archive_specs[fileformat][1],

                         prefix='%s-%s' % (repo_name, revision))

        response.content_type = archive_specs[fileformat][0]

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

        archive.seek(0)

        return read_in_chunks(archive)

    def diff(self, repo_name, f_path):

        hg_model = ScmModel()

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

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

        c.action = request.GET.get('diff')

        c.no_changes = diff1 == diff2

        c.f_path = f_path

        c.repo = hg_model.get_repo(c.repo_name)

        try:

            if diff1 not in ['', None, 'None', '0' * 12, '0' * 40]:

                c.changeset_1 = c.repo.get_changeset(diff1)

                node1 = c.changeset_1.get_node(f_path)

            else:

                c.changeset_1 = EmptyChangeset()

                node1 = FileNode('.', '', changeset=c.changeset_1)

            if diff2 not in ['', None, 'None', '0' * 12, '0' * 40]:

                c.changeset_2 = c.repo.get_changeset(diff2)

                node2 = c.changeset_2.get_node(f_path)

            else:

                c.changeset_2 = EmptyChangeset()

                node2 = FileNode('.', '', changeset=c.changeset_2)

        except RepositoryError: