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

"""

 (c) 2014-2018 - Copyright Red Hat Inc

 Authors:

   Pierre-Yves Chibon <pingou@pingoured.fr></pingou@pingoured.fr>

   Farhaan Bukhsh <farhaan.bukhsh@gmail.com></farhaan.bukhsh@gmail.com>

"""

# pylint: disable=too-many-lines

# pylint: disable=too-many-branches

# pylint: disable=too-many-locals

# pylint: disable=too-many-statements

# pylint: disable=bare-except

# pylint: disable=broad-except

from __future__ import unicode_literals, absolute_import

import datetime

import json

import logging

import os

import re

from math import ceil

import flask

import pygit2

import kitchen.text.converters as ktc

import six

import werkzeug

from six import BytesIO

from PIL import Image

from sqlalchemy.exc import SQLAlchemyError

from binaryornot.helpers import is_binary_string

import pagure.exceptions

import pagure.lib.git

import pagure.lib.mimetype

import pagure.lib.plugins

import pagure.lib.query

import pagure.lib.tasks

import pagure.forms

import pagure.ui.plugins

from pagure.config import config as pagure_config

from pagure.flask_app import _get_user

from pagure.lib import encoding_utils

from pagure.ui import UI_NS

from pagure.utils import (

    __get_file_in_tree,

    login_required,

    is_true,

    stream_template,

)

from pagure.decorators import (

    is_repo_admin,

    is_admin_sess_timedout,

    has_issue_tracker,

    has_issue_or_pr_enabled,

    has_pr_enabled,

)

_log = logging.getLogger(__name__)

def get_preferred_readme(tree):

    """ Establish some order about which README gets displayed

    if there are several in the repository. If none of the listed

    README files is availabe, display either the next file that

    starts with 'README' or nothing at all.

    """

    order = ["README.md", "README.rst", "README", "README.txt"]

    readmes = [x for x in tree if x.name.startswith("README")]

    if len(readmes) > 1:

        for i in order:

            for j in readmes:

                if i == j.name:

                    return j

    elif len(readmes) == 1:

        return readmes[0]

    return None

@UI_NS.route("/<repo>.git")</repo>

@UI_NS.route("/<namespace>/<repo>.git")</repo></namespace>

@UI_NS.route("/fork/<username>/<repo>.git")</repo></username>

@UI_NS.route("/fork/<username>/<namespace>/<repo>.git")</repo></namespace></username>

def view_repo_git(repo, username=None, namespace=None):

    """ Redirect to the project index page when user wants to view

    the git repo of the project

    """

    return flask.redirect(

        flask.url_for(

            "ui_ns.view_repo",

            repo=repo,

            username=username,

            namespace=namespace,

        )

    )

@UI_NS.route("/<repo>/")</repo>

@UI_NS.route("/<repo>")</repo>

@UI_NS.route("/<namespace>/<repo>/")</repo></namespace>

@UI_NS.route("/<namespace>/<repo>")</repo></namespace>

@UI_NS.route("/fork/<username>/<repo>/")</repo></username>

@UI_NS.route("/fork/<username>/<repo>")</repo></username>

@UI_NS.route("/fork/<username>/<namespace>/<repo>/")</repo></namespace></username>

@UI_NS.route("/fork/<username>/<namespace>/<repo>")</repo></namespace></username>

def view_repo(repo, username=None, namespace=None):

    """ Front page of a specific repo.

    """

    repo_db = flask.g.repo

    repo_obj = flask.g.repo_obj

    if not repo_obj.is_empty and not repo_obj.head_is_unborn:

        head = repo_obj.head.shorthand

    else:

        head = None

    cnt = 0

    last_commits = []

    tree = []

    if not repo_obj.is_empty:

        try:

            for commit in repo_obj.walk(

                repo_obj.head.target, pygit2.GIT_SORT_NONE

            ):

                last_commits.append(commit)

                cnt += 1

                if cnt == 3:

                    break

            tree = sorted(last_commits[0].tree, key=lambda x: x.filemode)

        except pygit2.GitError:

            pass

    readme = None

    safe = False

    if not repo_obj.is_empty and not repo_obj.head_is_unborn:

        branchname = repo_obj.head.shorthand

    else:

        branchname = None

    project = pagure.lib.query.get_authorized_project(

        flask.g.session, repo, user=username, namespace=namespace

    )

    watch_users = set()

    watch_users.add(project.user.username)

    for access_type in project.access_users.keys():

        for user in project.access_users[access_type]:

            watch_users.add(user.username)

    for watcher in project.watchers:

        if watcher.watch_issues or watcher.watch_commits:

            watch_users.add(watcher.user.username)

    readmefile = get_preferred_readme(tree)

    if readmefile:

        name, ext = os.path.splitext(readmefile.name)

        content = __get_file_in_tree(

            repo_obj, last_commits[0].tree, [readmefile.name]

        ).data

        readme, safe = pagure.doc_utils.convert_readme(

            content,

            ext,

            view_file_url=flask.url_for(

                "ui_ns.view_raw_file",

                username=username,

                repo=repo_db.name,

                identifier=branchname,

                filename="",

            ),

        )

    return flask.render_template(

        "repo_info.html",

        select="overview",

        repo=repo_db,

        username=username,

        head=head,

        readme=readme,

        safe=safe,

        origin="view_repo",

        branchname=branchname,

        last_commits=last_commits,

        tree=tree,

        num_watchers=len(watch_users),

    )

"""

@UI_NS.route('/<repo>/branch/<path:branchname>')</path:branchname></repo>

@UI_NS.route('/<namespace>/<repo>/branch/<path:branchname>')</path:branchname></repo></namespace>

@UI_NS.route('/fork/<username>/<repo>/branch/<path:branchname>')</path:branchname></repo></username>

@UI_NS.route('/fork/<username>/<namespace>/<repo>/branch/<path:branchname>')</path:branchname></repo></namespace></username>

def view_repo_branch(repo, branchname, username=None, namespace=None):

    ''' Returns the list of branches in the repo. '''

    repo = flask.g.repo

    repo_obj = flask.g.repo_obj

    if branchname not in repo_obj.listall_branches():

        flask.abort(404, description='Branch not found')

    branch = repo_obj.lookup_branch(branchname)

    if not repo_obj.is_empty and not repo_obj.head_is_unborn:

        head = repo_obj.head.shorthand

    else:

        head = None

    cnt = 0

    last_commits = []

    for commit in repo_obj.walk(branch.peel().hex, pygit2.GIT_SORT_NONE):

        last_commits.append(commit)

        cnt += 1

        if cnt == 3:

            break

    diff_commits = []

    if repo.is_fork and repo.parent:

        parentname = repo.parent.repopath('main')

    else:

        parentname = repo.repopath('main')

    orig_repo = pygit2.Repository(parentname)

    tree = None

    safe = False

    readme = None

    if not repo_obj.is_empty and not orig_repo.is_empty:

        if not orig_repo.head_is_unborn:

            compare_branch = orig_repo.lookup_branch(orig_repo.head.shorthand)

        else:

            compare_branch = None

        commit_list = []

        if compare_branch:

            commit_list = [

                commit.oid.hex

                for commit in orig_repo.walk(

                    compare_branch.peel().hex,

                    pygit2.GIT_SORT_NONE)

            ]

        repo_commit = repo_obj[branch.peel().hex]

        for commit in repo_obj.walk(

                repo_commit.oid.hex, pygit2.GIT_SORT_NONE):

            if commit.oid.hex in commit_list:

                break

            diff_commits.append(commit.oid.hex)

        tree = sorted(last_commits[0].tree, key=lambda x: x.filemode)

        for i in tree:

            name, ext = os.path.splitext(i.name)

            if name == 'README':

                content = __get_file_in_tree(

                    repo_obj, last_commits[0].tree, [i.name]).data

                readme, safe = pagure.doc_utils.convert_readme(

                    content, ext,

                    view_file_url=flask.url_for(

                        'ui_ns.view_raw_file', username=username,

                        namespace=repo.namespace,

                        repo=repo.name, identifier=branchname, filename=''))

    return flask.render_template(

        'repo_info.html',

        select='overview',

        repo=repo,

        head=head,

        username=username,

        branchname=branchname,

        origin='view_repo_branch',

        last_commits=last_commits,

        tree=tree,

        safe=safe,

        readme=readme,

        diff_commits=diff_commits,

    )

"""

@UI_NS.route("/<repo>/commits/")</repo>

@UI_NS.route("/<repo>/commits")</repo>

@UI_NS.route("/<repo>/commits/<path:branchname>")</path:branchname></repo>

@UI_NS.route("/<namespace>/<repo>/commits/")</repo></namespace>

@UI_NS.route("/<namespace>/<repo>/commits")</repo></namespace>

@UI_NS.route("/<namespace>/<repo>/commits/<path:branchname>")</path:branchname></repo></namespace>

@UI_NS.route("/fork/<username>/<repo>/commits/")</repo></username>

@UI_NS.route("/fork/<username>/<repo>/commits")</repo></username>

@UI_NS.route("/fork/<username>/<repo>/commits/<path:branchname>")</path:branchname></repo></username>

@UI_NS.route("/fork/<username>/<namespace>/<repo>/commits/")</repo></namespace></username>

@UI_NS.route("/fork/<username>/<namespace>/<repo>/commits")</repo></namespace></username>

@UI_NS.route("/fork/<username>/<namespace>/<repo>/commits/<path:branchname>")</path:branchname></repo></namespace></username>

def view_commits(repo, branchname=None, username=None, namespace=None):

    """ Displays the commits of the specified repo.

    """

    repo = flask.g.repo

    repo_obj = flask.g.repo_obj

    commit = None

    branch = None

    if branchname and branchname in repo_obj.listall_branches():

        branch = repo_obj.lookup_branch(branchname)

        commit = branch.peel(pygit2.Commit)

    elif branchname:

        try:

            commit = repo_obj.get(branchname)

        except (ValueError, TypeError):

            pass

        if "refs/tags/%s" % branchname in list(repo_obj.references):

            ref = repo_obj.lookup_reference("refs/tags/%s" % branchname)

            commit = ref.peel(pygit2.Commit)

        # If we're arriving here from the release page, we may have a Tag

        # where we expected a commit, in this case, get the actual commit

        if isinstance(commit, pygit2.Tag):

            commit = commit.peel(pygit2.Commit)

            branchname = commit.oid.hex

    elif not repo_obj.is_empty and not repo_obj.head_is_unborn:

        branch = repo_obj.lookup_branch(repo_obj.head.shorthand)

        commit = branch.peel(pygit2.Commit)

        branchname = branch.branch_name

    if not repo_obj.is_empty and not repo_obj.head_is_unborn:

        head = repo_obj.head.shorthand

    else:

        head = None

    try:

        page = int(flask.request.args.get("page", 1))

    except (ValueError, TypeError):

        page = 1

    author = flask.request.args.get("author", None)

    author_obj = None

    if author:

        try:

            author_obj = pagure.lib.query.get_user(flask.g.session, author)

        except pagure.exceptions.PagureException:

            pass

        if not author_obj:

            flask.flash("No user found for the author: %s" % author, "error")

    limit = pagure_config["ITEM_PER_PAGE"]

    start = limit * (page - 1)

    end = limit * page

    n_commits = 0

    last_commits = []

    if commit:

        for commit in repo_obj.walk(commit.hex, pygit2.GIT_SORT_NONE):

            # Filters the commits for a user

            if author_obj:

                tmp = False

                for email in author_obj.emails:

                    if email.email == commit.author.email:

                        tmp = True

                        break

                if not tmp:

                    continue

            if n_commits >= start and n_commits <= end:

                last_commits.append(commit)

            n_commits += 1

    total_page = int(ceil(n_commits / float(limit)) if n_commits > 0 else 1)

    diff_commits = []

    diff_commits_full = []

    if repo.is_fork and repo.parent:

        parentname = repo.parent.repopath("main")

    else:

        parentname = repo.repopath("main")

    orig_repo = pygit2.Repository(parentname)

    if (

        not repo_obj.is_empty

        and not orig_repo.is_empty

        and len(repo_obj.listall_branches()) > 1

    ):

        if not orig_repo.head_is_unborn:

            compare_branch = orig_repo.lookup_branch(orig_repo.head.shorthand)

        else:

            compare_branch = None

        if compare_branch and branch:

            (

                diff,

                diff_commits_full,

                orig_commit,

            ) = pagure.lib.git.get_diff_info(

                repo_obj,

                orig_repo,

                branch.branch_name,

                compare_branch.branch_name,

            )

            for commit in diff_commits_full:

                diff_commits.append(commit.oid.hex)

    return flask.render_template(

        "commits.html",

        select="commits",

        origin="view_commits",

        repo=repo,

        username=username,

        head=head,

        branchname=branchname,

        last_commits=last_commits,

        diff_commits=diff_commits,

        diff_commits_full=diff_commits_full,

        number_of_commits=n_commits,

        page=page,

        total_page=total_page,

        flag_statuses_labels=json.dumps(pagure_config["FLAG_STATUSES_LABELS"]),

    )

@UI_NS.route("/<repo>/c/<commit1>..<commit2>/")</commit2></commit1></repo>

@UI_NS.route("/<repo>/c/<commit1>..<commit2>")</commit2></commit1></repo>

@UI_NS.route("/<namespace>/<repo>/c/<commit1>..<commit2>/")</commit2></commit1></repo></namespace>

@UI_NS.route("/<namespace>/<repo>/c/<commit1>..<commit2>")</commit2></commit1></repo></namespace>

@UI_NS.route("/fork/<username>/<repo>/c/<commit1>..<commit2>/")</commit2></commit1></repo></username>

@UI_NS.route("/fork/<username>/<repo>/c/<commit1>..<commit2>")</commit2></commit1></repo></username>

@UI_NS.route("/fork/<username>/<namespace>/<repo>/c/<commit1>..<commit2>/")</commit2></commit1></repo></namespace></username>

@UI_NS.route("/fork/<username>/<namespace>/<repo>/c/<commit1>..<commit2>")</commit2></commit1></repo></namespace></username>

def compare_commits(repo, commit1, commit2, username=None, namespace=None):

    """ Compares two commits for specified repo

    """

    repo = flask.g.repo

    repo_obj = flask.g.repo_obj

    if not repo_obj.is_empty and not repo_obj.head_is_unborn:

        head = repo_obj.head.shorthand

    else:

        head = None

    # Check commit1 and commit2 existence

    commit1_obj = repo_obj.get(commit1)

    commit2_obj = repo_obj.get(commit2)

    if commit1_obj is None:

        flask.abort(404, description="First commit does not exist")

    if commit2_obj is None:

        flask.abort(404, description="Last commit does not exist")

    # Get commits diff data

    diff = repo_obj.diff(commit1, commit2)

    # Get commits list

    diff_commits = []

    order = pygit2.GIT_SORT_NONE

    first_commit = commit1

    last_commit = commit2

    commits = [

        commit.oid.hex[: len(first_commit)]

        for commit in repo_obj.walk(last_commit, pygit2.GIT_SORT_NONE)

    ]

    if first_commit not in commits:

        first_commit = commit2

        last_commit = commit1

    for commit in repo_obj.walk(last_commit, order):

        diff_commits.append(commit)

        if commit.oid.hex == first_commit or commit.oid.hex.startswith(

            first_commit

        ):

            break

    if first_commit == commit2:

        diff_commits.reverse()

    return flask.render_template(

        "repo_comparecommits.html",

        select="commits",

        origin="compare_commits",

        repo=repo,

        username=username,

        head=head,

        commit1=commit1,

        commit2=commit2,

        diff=diff,

        diff_commits=diff_commits,

    )

@UI_NS.route("/<repo>/blob/<path:identifier>/f/<path:filename>")</path:filename></path:identifier></repo>

@UI_NS.route("/<namespace>/<repo>/blob/<path:identifier>/f/<path:filename>")</path:filename></path:identifier></repo></namespace>

@UI_NS.route(

    "/fork/<username>/<repo>/blob/<path:identifier>/f/<path:filename>"</path:filename></path:identifier></repo></username>

)

@UI_NS.route(

    "/fork/<username>/<namespace>/<repo>/blob/<path:identifier>/f/"</path:identifier></repo></namespace></username>

    "<path:filename>"</path:filename>

)

def view_file(repo, identifier, filename, username=None, namespace=None):

    """ Displays the content of a file or a tree for the specified repo.

    """

    repo = flask.g.repo

    repo_obj = flask.g.repo_obj

    if repo_obj.is_empty:

        flask.abort(404, description="Empty repo cannot have a file")

    if identifier in repo_obj.listall_branches():

        branchname = identifier

        branch = repo_obj.lookup_branch(identifier)

        commit = branch.peel(pygit2.Commit)

    else:

        try:

            commit = repo_obj.get(identifier)

            branchname = identifier

        except ValueError:

            if "master" not in repo_obj.listall_branches():

                flask.abort(404, description="Branch not found")

            # If it's not a commit id then it's part of the filename

            commit = repo_obj[repo_obj.head.target]

            branchname = "master"

    if isinstance(commit, pygit2.Tag):

        commit = commit.peel(pygit2.Commit)

    tree = None

    if isinstance(commit, pygit2.Tree):

        tree = commit

    elif isinstance(commit, pygit2.Commit):

        tree = commit.tree

    if tree and commit and not isinstance(commit, pygit2.Blob):

        content = __get_file_in_tree(

            repo_obj, tree, filename.split("/"), bail_on_tree=True

        )

        if not content:

            flask.abort(404, description="File not found")

        content = repo_obj[content.oid]

    else:

        content = commit

    if not content:

        flask.abort(404, description="File not found")

    readme = None

    safe = False

    readme_ext = None

    headers = {}

    huge = False

    isbinary = False

    if "data" in dir(content):

        isbinary = is_binary_string(content.data)

    if isinstance(content, pygit2.Blob):

        rawtext = is_true(flask.request.args.get("text"))

        ext = filename[filename.rfind(".") :]

        if ext in (

            ".gif",

            ".png",

            ".bmp",

            ".tif",

            ".tiff",

            ".jpg",

            ".jpeg",

            ".ppm",

            ".pnm",

            ".pbm",

            ".pgm",

            ".webp",

            ".ico",

        ):

            try:

                Image.open(BytesIO(content.data))

                output_type = "image"

            except IOError as err:

                _log.debug("Failed to load image %s, error: %s", filename, err)

                output_type = "binary"

        elif ext in (".rst", ".mk", ".md", ".markdown") and not rawtext:

            content, safe = pagure.doc_utils.convert_readme(content.data, ext)

            output_type = "markup"

        elif "data" in dir(content) and not isbinary:

            file_content = None

            try:

                file_content = encoding_utils.decode(

                    ktc.to_bytes(content.data)

                )

            except pagure.exceptions.PagureException:

                # We cannot decode the file, so let's pretend it's a binary

                # file and let the user download it instead of displaying

                # it.

                output_type = "binary"

            if file_content is not None:

                output_type = "file"

                content = content.data.decode("utf-8")

            else:

                output_type = "binary"

        elif not isbinary:

            output_type = "file"

            huge = True

            safe = False

            content = content.data.decode("utf-8")

        else:

            output_type = "binary"

    elif isinstance(content, pygit2.Commit):

        flask.abort(404, description="File not found")

    else:

        content = sorted(content, key=lambda x: x.filemode)

        for i in content:

            name, ext = os.path.splitext(i.name)

            if not isinstance(name, six.text_type):

                name = name.decode("utf-8")

            if name == "README":

                readme_file = __get_file_in_tree(

                    repo_obj, content, [i.name]

                ).data

                readme, safe = pagure.doc_utils.convert_readme(

                    readme_file, ext

                )

                readme_ext = ext

        output_type = "tree"

    if output_type == "binary":

        headers[str("Content-Disposition")] = "attachment"

    return flask.Response(

        flask.stream_with_context(

            stream_template(

                flask.current_app,

                "file.html",

                select="tree",

                repo=repo,

                origin="view_file",

                username=username,

                branchname=branchname,

                filename=filename,

                content=content,

                output_type=output_type,

                readme=readme,

                readme_ext=readme_ext,

                safe=safe,

                huge=huge,

            )

        ),

        200,

        headers,

    )

@UI_NS.route("/<repo>/raw/<path:identifier>")</path:identifier></repo>

@UI_NS.route("/<namespace>/<repo>/raw/<path:identifier>")</path:identifier></repo></namespace>

@UI_NS.route("/<repo>/raw/<path:identifier>/f/<path:filename>")</path:filename></path:identifier></repo>

@UI_NS.route("/<namespace>/<repo>/raw/<path:identifier>/f/<path:filename>")</path:filename></path:identifier></repo></namespace>

@UI_NS.route("/fork/<username>/<repo>/raw/<path:identifier>")</path:identifier></repo></username>

@UI_NS.route("/fork/<username>/<namespace>/<repo>/raw/<path:identifier>")</path:identifier></repo></namespace></username>

@UI_NS.route("/fork/<username>/<repo>/raw/<path:identifier>/f/<path:filename>")</path:filename></path:identifier></repo></username>

@UI_NS.route(

    "/fork/<username>/<namespace>/<repo>/raw/<path:identifier>/f/"</path:identifier></repo></namespace></username>

    "<path:filename>"</path:filename>

)

def view_raw_file(

    repo, identifier, filename=None, username=None, namespace=None

):

    """ Displays the raw content of a file of a commit for the specified repo.

    """

    repo_obj = flask.g.repo_obj

    if repo_obj.is_empty:

        flask.abort(404, description="Empty repo cannot have a file")

    if identifier in repo_obj.listall_branches():

        branch = repo_obj.lookup_branch(identifier)

        commit = branch.peel(pygit2.Commit)

    else:

        try:

            commit = repo_obj.get(identifier)

        except ValueError:

            if "master" not in repo_obj.listall_branches():

                flask.abort(404, description="Branch not found")

            # If it's not a commit id then it's part of the filename

            commit = repo_obj[repo_obj.head.target]

    if not commit:

        flask.abort(404, description="Commit %s not found" % (identifier))

    if isinstance(commit, pygit2.Tag):

        commit = commit.peel(pygit2.Commit)

    if filename:

        if isinstance(commit, pygit2.Blob):

            content = commit

        else:

            content = __get_file_in_tree(

                repo_obj, commit.tree, filename.split("/"), bail_on_tree=True

            )

        if not content or isinstance(content, pygit2.Tree):

            flask.abort(404, description="File not found")

        data = repo_obj[content.oid].data

    else:

        if commit.parents:

            # We need to take this not so nice road to ensure that the

            # identifier retrieved from the URL is actually valid

            try:

                parent = repo_obj.revparse_single("%s^" % identifier)

                diff = repo_obj.diff(parent, commit)

            except (KeyError, ValueError):

                flask.abort(404, description="Identifier not found")

        else:

            # First commit in the repo

            diff = commit.tree.diff_to_tree(swap=True)

        data = diff.patch

    if not data:

        flask.abort(404, description="No content found")

    return (data, 200, pagure.lib.mimetype.get_type_headers(filename, data))

@UI_NS.route("/<repo>/blame/<path:filename>")</path:filename></repo>

@UI_NS.route("/<namespace>/<repo>/blame/<path:filename>")</path:filename></repo></namespace>

@UI_NS.route("/fork/<username>/<repo>/blame/<path:filename>")</path:filename></repo></username>

@UI_NS.route("/fork/<username>/<namespace>/<repo>/blame/<path:filename>")</path:filename></repo></namespace></username>

def view_blame_file(repo, filename, username=None, namespace=None):

    """ Displays the blame of a file or a tree for the specified repo.

    """

    repo = flask.g.repo

    repo_obj = flask.g.repo_obj

    branchname = flask.request.args.get("identifier")

    if repo_obj.is_empty:

        flask.abort(404, description="Empty repo cannot have a file")

    if branchname is None:

        if repo_obj.head_is_unborn:

            flask.abort(

                404, description="Identifier is mandatory on unborn HEAD repos"

            )

        branchname = repo_obj.head.shorthand

        commit = repo_obj[repo_obj.head.target]

    else:

        if branchname in repo_obj.listall_branches():

            branch = repo_obj.lookup_branch(branchname)

            commit = branch.peel(pygit2.Commit)

        elif branchname in pagure.lib.git.get_git_tags(repo):

            branch = repo_obj.lookup_reference(

                "refs/tags/{}".format(branchname)

            )

            commit = branch.peel(pygit2.Commit)

        else:

            try:

                commit = repo_obj[branchname]

            except ValueError:

                flask.abort(

                    404, description="Cannot find specified identifier"

                )

    if isinstance(commit, pygit2.Tag):

        commit = commit.peel(pygit2.Commit)

    content = __get_file_in_tree(

        repo_obj, commit.tree, filename.split("/"), bail_on_tree=True

    )

    if not content:

        flask.abort(404, description="File not found")

    if not isinstance(content, pygit2.Blob):

        flask.abort(404, description="File not found")

    if is_binary_string(content.data):

        flask.abort(400, description="Binary files cannot be blamed")

    try:

        content = encoding_utils.decode(content.data)

    except pagure.exceptions.PagureException:

        # We cannot decode the file, so bail but warn the admins

        _log.exception("File could not be decoded")

        flask.abort(500, description="File could not be decoded")

    blame = repo_obj.blame(filename, newest_commit=commit.oid.hex)

    return flask.render_template(

        "blame.html",

        select="tree",

        repo=repo,

        origin="view_file",

        username=username,

        filename=filename,

        branchname=branchname,

        content=content,

        output_type="blame",

        blame=blame,

    )

@UI_NS.route("/<repo>/c/<commitid>/")</commitid></repo>

@UI_NS.route("/<repo>/c/<commitid>")</commitid></repo>

@UI_NS.route("/<namespace>/<repo>/c/<commitid>/")</commitid></repo></namespace>

@UI_NS.route("/<namespace>/<repo>/c/<commitid>")</commitid></repo></namespace>

@UI_NS.route("/fork/<username>/<repo>/c/<commitid>/")</commitid></repo></username>

@UI_NS.route("/fork/<username>/<repo>/c/<commitid>")</commitid></repo></username>

@UI_NS.route("/fork/<username>/<namespace>/<repo>/c/<commitid>/")</commitid></repo></namespace></username>

@UI_NS.route("/fork/<username>/<namespace>/<repo>/c/<commitid>")</commitid></repo></namespace></username>

def view_commit(repo, commitid, username=None, namespace=None):

    """ Render a commit in a repo

    """

    repo = flask.g.repo

    if not repo:

        flask.abort(404, description="Project not found")

    repo_obj = flask.g.repo_obj

    branchname = flask.request.args.get("branch", None)

    splitview = flask.request.args.get("splitview", False)

    if "splitview" in flask.request.args:

        splitview = True

    else:

        splitview = False

    if branchname and branchname not in repo_obj.listall_branches():

        branchname = None

    try:

        commit = repo_obj.get(commitid)

    except ValueError:

        flask.abort(404, description="Commit not found")

    if commit is None:

        flask.abort(404, description="Commit not found")

    if isinstance(commit, pygit2.Blob):

        flask.abort(404, description="Commit not found")

    if commit.parents:

        diff = repo_obj.diff(commit.parents[0], commit)

    else:

        # First commit in the repo

        diff = commit.tree.diff_to_tree(swap=True)

    if diff:

        diff.find_similar()

    return flask.render_template(

        "commit.html",

        select="commits",

        repo=repo,

        branchname=branchname,

        username=username,

        commitid=commitid,

        commit=commit,

        diff=diff,

        splitview=splitview,

        flags=pagure.lib.query.get_commit_flag(

            flask.g.session, repo, commitid

        ),

    )

@UI_NS.route("/<repo>/c/<commitid>.patch")</commitid></repo>

@UI_NS.route("/<namespace>/<repo>/c/<commitid>.patch")</commitid></repo></namespace>

@UI_NS.route("/fork/<username>/<repo>/c/<commitid>.patch")</commitid></repo></username>

@UI_NS.route("/fork/<username>/<namespace>/<repo>/c/<commitid>.patch")</commitid></repo></namespace></username>

def view_commit_patch(repo, commitid, username=None, namespace=None):

    """ Render a commit in a repo as patch

    """