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(c.rhodecode_repo,

                                           c.file, f_path)

        c.cs = cs

        c.f_path = f_path

        return render('files/files_annotate.html')

    def archivefile(self, repo_name, fname):

        fileformat = None

        revision = None

        ext = None

        for a_type, ext_data in ARCHIVE_SPECS.items():

            archive_spec = fname.split(ext_data[1])

            if len(archive_spec) == 2 and archive_spec[1] == '':

                fileformat = a_type or ext_data[1]

                revision = archive_spec[0]

                ext = ext_data[1]

        try:

            dbrepo = RepoModel().get_by_repo_name(repo_name)

            if dbrepo.enable_downloads is False:

                return _('downloads disabled')

            cs = c.rhodecode_repo.get_changeset(revision)

            content_type = ARCHIVE_SPECS[fileformat][0]

        except ChangesetDoesNotExistError:

            return _('Unknown revision %s') % revision

        except EmptyRepositoryError:

            return _('Empty repository')

        except (ImproperArchiveTypeError, KeyError):

            return _('Unknown archive type')

        response.content_type = content_type

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

            % (repo_name, revision, ext)

        return cs.get_chunked_archive(stream=tempfile.TemporaryFile(),

                                      kind=fileformat)

    def diff(self, repo_name, f_path):

        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

        try:

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

                c.changeset_1 = c.rhodecode_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.rhodecode_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:

            return redirect(url('files_home',

                                repo_name=c.repo_name, f_path=f_path))

        if c.action == 'download':

            diff = differ.DiffProcessor(differ.get_gitdiff(node1, node2),

                                        format='gitdiff')

            diff_name = '%s_vs_%s.diff' % (diff1, diff2)

            response.content_type = 'text/plain'

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

                                                    % diff_name

            return diff.raw_diff()

        elif c.action == 'raw':

            diff = differ.DiffProcessor(differ.get_gitdiff(node1, node2),

                                        format='gitdiff')

            response.content_type = 'text/plain'

            return diff.raw_diff()

        elif c.action == 'diff':

                                        format='gitdiff')

                c.cur_diff = diff.as_html()

        else:

            #default option

                c.cur_diff = _('Binary file')

            else:

                c.cur_diff = diff.as_html()

        return render('files/file_diff.html')

    def _get_history(self, repo, node, f_path):

        if not node.kind is NodeKind.FILE:

            return []

        changesets = node.history

        hist_l = []

        changesets_group = ([], _("Changesets"))

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

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

        for chs in changesets:

            n_desc = 'r%s:%s' % (chs.revision, chs.short_id)

            changesets_group[0].append((chs.raw_id, n_desc,))

        hist_l.append(changesets_group)

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

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

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

        hist_l.append(branches_group)

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

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

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

        hist_l.append(tags_group)

        return hist_l