gitar

    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 ..models import Repository

import git

def get_description(repository):

    """ Returns the Git repo description of the given repository.

    """

    if isinstance(repository, Repository):

        repository = git.Repo(repository.directory_path)

    return repository.description

def get_repository_object(repository_name):

    """ Checks the database for a repository with the same name, and returns a

    GitPython Repo object.

    Given the name of the repository, this function will search the database for

    a repository whoms name corresponds with the given name. When it found one, 

    Keyword arguments:

    repository_name -- The name of the repository

    """

    # Next line raises a Repository.DoesNotExist exception if not found, so it's

    # not necessary to check whether it was found or not.

    repository = Repository.objects.get(directory_path__endswith=repository_name+".git")

    return git.Repo(repository.directory_path)

def get_repository_model_object(repository_name):

    """ Functions identical to the get_repository_object, except that this

    function returns the Django model representation.

    Keyword arguments:

    repository_name -- The name of the repository

    """

    return Repository.objects.get(directory_path__endswith=repository_name+".git")

def read_file(file_blob):

    """ Reads the contents of the given file, and returns it in a list of

    strings.

    Reading the contents of a file using GitPython is a bit cumbersome. This

    function takes care of the hassle, and returns a list of unicode strings,

    allowing easy operations on the file's contents.

    """

    file_data_stream = file_blob.data_stream

    file_content = file_data_stream.read().decode("utf-8")

    file_formatted_content = []

    line = ""

    for character in file_content:

        if character != "\n":

            line = line + character

        else:

            file_formatted_content.append(line)

            line = ""

    return file_formatted_content

In essence, this means that in this module, a file's contents are being parsed

to Pygments, which will then return the appropriate HTML output, which can then

be directly parsed in a Django template.

"""

from pygments import highlight

from pygments.lexers import get_lexer_by_name

from pygments.formatters import HtmlFormatter

from pygments.lexers import guess_lexer_for_filename

def code_to_HTML(code, file_name):

    """ Turns the given list of code strings in HTML, ready for output.

    Please note that the lexer that will be used for the syntax coloring, is

    determined by the given file name, so assert that the given code comes from

    the given file.

    Keyword arguments:

    code -- A non-empty list of code strings.

    file_name -- The name of the file from where the given code originates.

    """

    lexer = guess_lexer_for_filename(file_name, code, stripall=True)

def decode_to_unicode(data):

    """ Decodes a given bytearray to a list of unicode strings."""

    #decoded_data = data.decode("utf-8")

    decoded_data = data

    formatted_data = []

    line = ""

    for character in decoded_data:

        if character != "\n":

            line = line + character

        else:

            formatted_data.append(line)

            line = ""

    return formatted_data

    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.conf.urls import url

from . import views # Imports the views from the same directory (which is views.py).

urlpatterns = [

        url(r'^$', views.index, name='gitar-index'),

        url(r'^(?P<repository_name>\w+)$', views.repositories, name='gitar-repository'),

        ]

    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.core.urlresolvers import reverse 

from .models import *

from .GitActions import RepoInfo

from git import Repo  # GitPython functionality.

import git

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 = [

            ['Source', 'OHGODHELPNOTDONEYET'],

            ]

    return footer_links

def standard_context():

    context = {

            'materialDesign_color': "blue-grey",

            'materialDesign_accentColor': "green",

            'navbar_title': "Gitar",

            'navbar_backArrow': False,

            'footer_title': "Gitar",

            'footer_description': footer_description(),

            'footer_links': footer_links(),

            }

    return context

# 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.html"

    # 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):

    # I first form the repository link out the given name.

def path_explorer(request, repository_name, 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: If the user gives a "<something>/../<somethingElse>", that should

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

    # already.

    directory = repository.heads.master.commit.tree

    for i in range(len(path_parts)-1):

        if len(subdirectories) == 0:

            for subdirectory in subdirectories:

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

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

    template to display this data.

    """

    # Collecting all files:

    files = directory.blobs

    file_names = []

    for ffile in files:

        file_names.append(ffile.name)

    # Collecting all subdirectories:

    subdirectories = directory.trees

    subdirectory_names = []

    for subdirectory in subdirectories:

        subdirectory_names.append(subdirectory.name)

    # Collecting rendering information:

    template = "gitar/directory.html"

    context = standard_context()

    context["files"] = file_names

    context["subdirectories"] = subdirectory_names

    return render(request, template, context)

def file_view(request, repository_name, path, ffile):

    """ 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 = ffile.data_stream.read()

    html_code = code_to_HTML(raw_file_data, ffile.name)

    # Collecting rendering information:

    template = "gitar/file.html"

    context = standard_context()

    context["content"] = html_code

    return render(request, template, context)