gitar

""" views.py - Describes the different views that can be presented to the user.

    Copyright © 2016 Maarten "Vngngdn" Vangeneugden

    This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU Affero 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 Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License

    along with this program. If not, see https://www.gnu.org/licenses/agpl.html.

"""

from django.shortcuts import get_object_or_404, render  # This allows to render the template with the view here. It's pretty cool and important.

from django.http import HttpResponseRedirect, HttpResponse

from django.urls import reverse

from .models import *

from .SvgBuilder import *

from .GitActions import RepoInfo, FileInfo, CommitInfo

from django.utils.translation import gettext as _

from git import Repo  # GitPython functionality.

import git

import pydriller

import datetime

from .syntax import *

# First, I list some standard variables that are common for most of the sites of this app.

def footer_description():

    return _("Gitar is a simple web app that allows its users to easily share Git repos in combination with the Django framework.")

def footer_links():

    footer_links = [

            [_('Home page'), reverse('about-index')],

            #[_('Source code'), reverse('gitar-repository', kwargs={'repository_name':'gitar'})],

            ]

    return footer_links

def standard_context():

    context = {

            'navbar_title': "Gitar",

            'navbar_backArrow': False,

            'footer_title': "Gitar",

            'footer_description': footer_description(),

            'footer_links': footer_links(),

            'stylesheet_name': "gitar",

            }

    return context

def download_tar(request):

    pass

def download_git(request):

    pass

def commit(request, repository_name, commit_hash):

    template = "gitar/commit.djhtml"

    repository_model = RepoInfo.get_repository_model(repository_name)

    commit_repo = pydriller.Repository(repository_model.directory_path, single=commit_hash)

    context = standard_context()

    #file_html_code = dict()

    context["modified_files"] = list()

    # NOTE: Although this looks like a for loop, it's not: It's a generator that

    # will only produce a single commit. But since it's a generator, I can't

    # extract the first element with indexing. So this will have to do.

    for c in commit_repo.traverse_commits():

        context["commit"] = c

        # Splitting up the message file correctly

        # case: Only summary line, no \n:

        if '\n' not in c.msg:

            context["first_line"] = c.msg

        # case: Summary line split by two \n:

        elif '\n' not in c.msg.split('\n\n', maxsplit=1)[0]:

            parts = c.msg.split('\n\n', maxsplit=1)

            context["first_line"] = parts[0]

            context["other_lines"] = parts[1]

        # case: Badly formatted message

        else:

            parts = c.msg.split('\n', maxsplit=1)

            context["first_line"] = parts[0]

            context["other_lines"] = parts[1]

        # Final formatting:

        if "other_lines" in context:

            context["other_lines"] = context["other_lines"].replace('\n\n','<br>').replace('\n', ' ')

        # Processing the modified files

        for modified_file in c.modified_files:

            #print("FILE")

            processed = CommitInfo.prepare_and_process(modified_file)

            #print(processed)

            context["modified_files"].append(processed)

            #html_code_before = None

            #html_code_after = None

            #if modified_file.source_code_before is not None:

                #html_code_before = code_to_HTML(

                    #modified_file.source_code_before,

                    #modified_file.filename)

            #if modified_file.source_code is not None:

                #html_code_after = code_to_HTML(

                    #modified_file.source_code,

                    #modified_file.filename)

            # XXX: This function WILL OVERWRITE the presented code of a file if

            # this particular commit includes multiple files with the same name,

            # but a different path. I'll update this in the future...

            #file_html_code[modified_file.filename] = (html_code_before, html_code)

    #context["file_html_code"] = file_html_code

    #context["subdirectories"] = subdirectories

    #context["commits"] = commits

    #context["branch"] = branch

    context["repository_name"] = repository_name

    # Adding the html code for the files

    #context["file_html_code"]

    #context["repository_description"] = repository.description

    #html_code = code_to_HTML(raw_file_data, file.name)

    return render(request, template, context)

def file_commit(request):

    pass

# From here, the actual views start.

def index(request):

    """ The start page of Gitar.

    The goal of this view, is to collect all the available repositories,

    including some additional information, such as programming language,

    license, description, ... in order to give a fast overview of the most

    prominent information.

    """

    # Collecting the available repositories:

    # Template:

    template = "gitar/index.djhtml"

    # Requesting the repositories:

    modelRepos = Repository.objects.all()

    # From here, we start collecting info about all the repositories:

    class BlankRepository: pass  # Blank object in which all data will be collected.

    repositories = []

    for modelRepo in modelRepos:

        repository = BlankRepository()

        # TODO: Find a way to add all of modelRepo's fields without having to

        # hardcode them. This is prone to errors and is redundant.

        repository.name = str(modelRepo)

        repository.programmingLanguage = modelRepo.programmingLanguage

        repository.license = modelRepo.license

        repository.description = RepoInfo.get_description(modelRepo)

        #gitRepo = Repo.init(modelRepo.directory(), bare=True)  # Connects to the Git Repo.

        # See tests.py, which assures all repositories exist. Tests are handy.

        #repository.description = gitRepo.description

        # This is mostly personal taste, but I like to show the amount of files.

        #repoTree = gitRepo.heads.master.commit.tree

        #repository.fileCount = len(repoTree.blobs)  # blobs are files.

        repositories.append(repository)

    # After that, I extend the standard context with the repositories:

    context = standard_context()

    context['repositories'] = repositories

    # And finally, sending everything back.

    return render(request, template, context)

def repositories(request, repository_name, branch="master"):

    # A repo's root is a directory by default, so this will automatically return

    # a directory view. But still, this is a bit nicer.

    return path_explorer(request, repository_name, branch, "")

def path_explorer(request, repository_name, branch, path=""):

    """ Checks whether the given path is a file or a directory, and calls the

    appropriate view function accordingly.

    """

    repository = RepoInfo.get_repository_object(repository_name)

    # From the GitPython documentation:

    # You can obtain the tree object of a repository, which is the directory of

    # that repo. This tree can be accessed as if it were a native Python list,

    # where the elements are the subdirectories and files. So, the idea to

    # determine whether a file, or a directory was requested, is simple:

    # 1. Split the path with "/" as seperator.

    # 2. Replace the current tree variable with the one retrieved from the

    # subtree element

    # 3. Repeat 2. until all parts of the given path are exhausted.

    # If we now still have a tree, we're looking at a directory, so display the

    # files (and subdirectories) of this directory.

    # Else, if we hit a blob, display the file contents.

    path_parts = path.split(sep="/")

    # FIXME: This is a bug at the URL regex part that I haven't been able to fix

    # yet. This serves as a temporary fix:

    # If the last part of the path is an empty string (which happens when the

    # last symbol was a '/'), remove that part from the list.

    # Of course, this is bad monkeypatching, but I suck at regex, so as long as

    # I don't find the solution, this'll have to do.

    #print(path_parts)

    if path_parts[len(path_parts)-1] == "":

        path_parts.pop()

    if len(path_parts) == 0:

        directory = repository.heads[branch].commit.tree

        return directory_view(request, repository_name, branch, path, directory)

    assert len(path_parts) != 0

    # FIXME: If the user gives a "<something>/../<somethingElse>", that should

    # become "<something>". Obviously, although I think that's done by default

    # already.

    directory = repository.heads[branch].commit.tree

    for i in range(len(path_parts)):

        subdirectories = directory.trees

        #if len(subdirectories) == 0:

            # This can't happen, as this would imply there is a directory inside

            # a file.

        #    assert False

        #else:

        for subdirectory in subdirectories:

            if subdirectory.name == path_parts[i]:

                directory = subdirectory

                #break  # Useless optimization

    # When there are no more directories to traverse, check if the last part of

    # the path is either a file, or a directory:

    blobs = directory.blobs

    #print(path_parts)

    last_part = path_parts[len(path_parts)-1]

    for blob in directory.blobs:

        #print(blob.name)

        if blob.name == last_part:

            file_blob = blob

            #print("Returning file view")

            return file_view(request, repository_name, branch, path, file_blob)

        else:

            pass

            #print("blob name: " + blob.name)

            #print("last part: " + last_part)

    return directory_view(request, repository_name, branch, path, directory)

def directory_view(request, repository_name, branch, path, directory):

    """ Collects the given directories's files and subdirectories, and renders a

    template to display this data.

    """

    # Collecting files in this directory

    repository = RepoInfo.get_repository_object(repository_name)

    files = []

    for file in directory.blobs:

        latest_commit_object = FileInfo.last_commit(repository_name, branch, file.path)

        older_than_one_month = (datetime.datetime.now(datetime.timezone.utc) - latest_commit_object.committer_date).days > 30

        #print(latest_commit_object)

        files.append({

            "name":file.name,

            "path":file.path,

            #"commit":"",#FileInfo.last_commit(repository, file).hexsha[:20],

            "commit": latest_commit_object,

            "older_than_one_month": older_than_one_month,

            })

        #print(FileInfo.last_commit(repository_name, branch, file))

    # Collecting commits for this branch

    commits = []

    for commit in repository.iter_commits(branch):

        commits.append({

            "hash":commit.hexsha[:20],

            "author":commit.author,

            "description":commit.summary,

            "date": datetime.datetime.fromtimestamp(commit.committed_date),

            })

    # Collecting subdirectories

    subdirectories = []

    for subdirectory in directory.trees:

        subdirectories.append({

            "path":subdirectory.path,

            "name":subdirectory.name,

            })

    # Collecting rendering information:

    template = "gitar/directory.djhtml"

    context = standard_context()

    context["files"] = files

    context["subdirectories"] = subdirectories

    context["commits"] = commits

    context["branch"] = branch

    context["repository_name"] = repository_name

    context["repository_description"] = repository.description

    # Collection repo information

    for repo in Repository.objects.all():

        if str(repo) == repository_name:

            context["repository_language"] = repo.programmingLanguage

            context["repository_license"] = repo.license

            break

    branches = []

    for bbranch in repository.heads:

        branches.append(bbranch.name)

    context["branches"] = branches

    # DEBUG

    shares = RepoInfo.get_directory_source_share(directory)

    context["shares_svg"] = language_share_svg(shares)

    tag_colours = dict()

    unknown_percentage = 1.0

    for language in shares.keys():

        unknown_percentage -= shares[language]

        shares[language] = (shares[language], language_css_gradient(language))

    context["file_shares"] = sorted(shares.items(), key=lambda x: x[1])[::-1]

    context["unknown_percentage"] = max(0.01, unknown_percentage) if unknown_percentage != 0.0 else 0

    #context["tag_colours"] = tag_colours

    #print(tag_colours)

    # END DEBUG

    return render(request, template, context)

def file_view(request, repository_name, branch, path, file):

    """ Collects the file contents of the given file path, and returns it to the

    template, with the file contents already formatted in HTML using Pygments.

    """

    # Turning the file's contents in HTML ready output:

    raw_file_data = file.data_stream.read()

    html_code = code_to_HTML(raw_file_data, file.name)

    # Collecting rendering information:

    template = "gitar/file.djhtml"

    context = standard_context()

    context["content"] = html_code

    context["file_name"] = file.name

    context["repository_name"] = repository_name

    return render(request, template, context)