gitar

# formatted file in a commit. 

# The function returns a list 

# If one line is removed, and one line is added, and both have the same line

# number, then that should be regarded as a changed line, not a removed+added line.

# This holds for each non-broken list of removed+added lines.

from pydriller.domain.commit import ModificationType

from ..syntax import *

""" It's a lot of annoying glue code to transform a modified file object into

what we actually want: The data that needs to be passed to the Django template.

This convenience function accepts the modified file object as given by

Pydriller's Commit class, and returns a list of dicts, each dict representing

the information needed to properly present a file diff in the template.

"""

def prepare_and_process(modified_file):

    #print(modified_file.source_code)

    result = dict()

    result["object"] = modified_file  # Could come in handy

    result["change_type"] = modified_file.change_type

    result["html_code_after"] = code_to_HTML(

        modified_file.source_code,

        modified_file.filename)

    result["html_code_before"] = code_to_HTML(

        modified_file.source_code_before,

        modified_file.filename)

    if modified_file.change_type == ModificationType.ADD:

        result["path"] = modified_file.new_path

    elif modified_file.change_type == ModificationType.DELETE:

        result["path"] = modified_file.old_path

    elif modified_file.change_type == ModificationType.RENAME:

        result["path"] = modified_file.old_path +" → "+ modified_file.new_path

    elif modified_file.change_type == ModificationType.MODIFY:

        result["path"] = modified_file.old_path

    added = dict()

    deleted = dict()

    for number, line in modified_file.diff_parsed["added"]:

        added[number] = line

    for number, line in modified_file.diff_parsed["deleted"]:

        if result["path"] == "Challenge 4/Controller.java":

            print("PING")

    if result["path"] == "Challenge 4/Controller.java":

        print("NU CONTROLLER.jAVA")

        print(deleted)

        result["html_code_before"],

        result["html_code_after"],

        added,

        deleted)

    # These three lists are going to be empty if the methods couldn't be detected

    deleted, transferred, new = process_methods(modified_file)

    if len(deleted) == len(transferred) == len(new) == 0:

        result["methods_available"] = False

    else:

        result["methods_available"] = True

        result["deleted_methods"] = deleted

        result["transferred_methods"] = transferred

        result["new_methods"] = new

    return result 

""" Sometimes, the methods in a file can be detected, which adds some nice

information """

def process_methods(modified_file):

    before_methods = modified_file.methods_before

    after_methods = modified_file.methods

    deleted_methods = []

    transferred_methods = []

    new_methods = []

    # Finding all transferred and deleted methods

    for before_method in before_methods:

        transferred = False

        for after_method in after_methods:

            if before_method.name == after_method.name:  # Match found

                transferred_methods.append((before_method, after_method))

                transferred = True

                break

        if not transferred:

            deleted_methods.append(before_method)

    # Finding all new methods

    for after_method in after_methods:

        transferred = False

        for _, am in transferred_methods:

            if after_method == am:

                transferred = True

                break

        if not transferred:

            new_methods.append(after_method)

    return deleted_methods, transferred_methods, new_methods

def process_file(source_before, source_after, additions, deletions): 

    rows = []

    # Counting from 1, because source code lines are counted from there

    # NOTE: Deletions komen wel degelijk goed binnen

    print("deletions:")

    after_count = 1

    while True:

        row = dict()

        #print("PROCESS_FILE")

        #print(deletions)

        #print(additions)

        # We check the deletion lines first; if a line was "changed", the

        # 'deleted' line needs to be listed first, and after that, the 'added'

        # line

        #print(str(before_count) + " -- " + str(after_count))

        if before_count in deletions:

            row["type"] = "deletion"

            row["old_num"] = before_count

            # Why source_before[] and not deletions[]?

            # Because source_before[] has been processed by Pygments, and thus

            # has the syntax highlighting in it. deletions[] is just plain text.

            row["line"] = source_before[before_count]

        elif after_count in additions:

            row["type"] = "addition"

            row["new_num"] = after_count

            # Idem for additions[]

            row["line"] = source_after[after_count]

        else:  # No change to this particular line

            row["old_num"] = before_count

            row["new_num"] = after_count

            if len(source_before) > before_count:

                row["line"] = source_before[before_count] 

            elif len(source_after) > after_count:

                row["line"] = source_after[after_count] 

            else:  # No lines left

                break

            # If not end of both files, increment both counters anyway

            before_count += 1

            after_count += 1

        # Adding the new row to the list of rows

        rows.append(row)

    return rows

# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER

# This file is distributed under the same license as the PACKAGE package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: PACKAGE VERSION\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2022-04-04 23:18+0000\n"

"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"

"Language-Team: LANGUAGE <LL@li.org>\n"

"Language: \n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Plural-Forms: nplurals=2; plural=(n != 1);\n"

#: gitar/views.py:39

"Gitar is a simple web app that allows its users to easily share Git repos in "

"combination with the Django framework."

msgstr ""

#: gitar/views.py:43

msgstr ""

# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER

# This file is distributed under the same license as the PACKAGE package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: PACKAGE VERSION\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2022-04-04 23:18+0000\n"

"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"

"Language-Team: LANGUAGE <LL@li.org>\n"

"Language: \n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Plural-Forms: nplurals=2; plural=(n != 1);\n"

#: gitar/views.py:39

"Gitar is a simple web app that allows its users to easily share Git repos in "

"combination with the Django framework."

msgstr ""

#: gitar/views.py:43

msgstr ""

# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER

# This file is distributed under the same license as the PACKAGE package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: PACKAGE VERSION\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2022-04-04 23:18+0000\n"

"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"

"Language-Team: LANGUAGE <LL@li.org>\n"

"Language: \n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Plural-Forms: nplurals=2; plural=(n != 1);\n"

#: gitar/views.py:39

"Gitar is a simple web app that allows its users to easily share Git repos in "

"combination with the Django framework."

msgstr ""

#: gitar/views.py:43

msgstr ""

# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER

# This file is distributed under the same license as the PACKAGE package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: PACKAGE VERSION\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2022-04-04 23:18+0000\n"

"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"

"Language-Team: LANGUAGE <LL@li.org>\n"

"Language: \n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Plural-Forms: nplurals=2; plural=(n != 1);\n"

#: gitar/views.py:39

"Gitar is a simple web app that allows its users to easily share Git repos in "

"combination with the Django framework."

msgstr ""

#: gitar/views.py:43

msgstr ""

# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER

# This file is distributed under the same license as the PACKAGE package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: PACKAGE VERSION\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2022-04-04 23:18+0000\n"

"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"

"Language-Team: LANGUAGE <LL@li.org>\n"

"Language: \n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Plural-Forms: nplurals=2; plural=(n > 1);\n"

#: gitar/views.py:39

"Gitar is a simple web app that allows its users to easily share Git repos in "

"combination with the Django framework."

msgstr ""

"Gitar est un application qui permet à ses utilisateurs de partager "

"facilement des repos Git, grace á le cadriciel Django."

#: gitar/views.py:43

msgstr "Page d'acceuil"

#~ msgid "Source code"

#~ msgstr "Code source"

# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER

# This file is distributed under the same license as the PACKAGE package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: PACKAGE VERSION\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2022-04-04 23:18+0000\n"

"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"

"Language-Team: LANGUAGE <LL@li.org>\n"

"Language: \n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Plural-Forms: nplurals=2; plural=(n != 1);\n"

#: gitar/views.py:39

"Gitar is a simple web app that allows its users to easily share Git repos in "

"combination with the Django framework."

msgstr ""

"Gitar is een simpele web app dat gebruikers toelaat gemakkelijk Git-repo's "

"met elkaar te delen, in combinatie met Django."

#: gitar/views.py:43

msgstr "Homepage"

#~ msgid "Source code"

#~ msgstr "Broncode"

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.

    """

    # stripall removes whitespace in front, but that also removes file

    # indentation.

    if code is None:

        return []

    try:

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

        # linenos (line-n°'s) adds line numbering to the front of the output. I'm

        # doing that myself, so False.

        # cssclass sets the enclosing <div>'s class to the given CSS class name.

        formatter = HtmlFormatter(linenos=False, cssclass="source")

        #result = highlight(code, lexer, formatter)

        unicode_data = decode_to_unicode(highlight(code, lexer, formatter))

        return unicode_data

    #except pygments.ClassNotFound as exception:

    except:

        # This happens with files lacking a file extension, and MarkDown files.

        # In that case, no lexer should be used, but Simple parse the same code.

        return no_syntax(code)

def no_syntax(data):

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

    if type(data) is str:

        decoded_data = data

    else:

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

    formatted_data = []

    line = ""

    for character in decoded_data:

        if character != "\n":

            line = line + character

        else:

            formatted_data.append(line)

            line = ""

    return formatted_data

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

{% load i18n %}

{% load humanize %}

{% load static %}

{% block title %}{{ repository_name }} | Gitar{% endblock title %}

{% block stylesheets %}

    {{ block.super }}

    <link rel="stylesheet" type="text/css" href="/static/website/syntax.css" />

    <link rel="stylesheet" type="text/css" href="/static/gitar/css/file.css" />

    <style>

    table.highlight {

        border-collapse: collapse;

    }

    table.highlight tr {

        line-height: 1em;

    }

    tr.deletion {

        background-color: rgba(255, 0, 0, .1);

    }

    tr.addition {

        background-color: rgba(0, 255, 0, .1);

    }

    section {

        overflow-x: scroll;

    }

    .symbol {

        text-align: right;

        /*font-weight: bolder;*/

    /* These vendor prefixes are still necessary, yeah...*/

    }

    .line-number {

        text-align: right;

        width: 3em;

        -moz-user-select: none;

        -webkit-user-select: none;

        -ms-user-select: none;

      user-select: none;

    }

    .line-number a {

        color: grey;

    }

    details span.opened {

        display: none;

    }

    details[open] span.opened {

         display: inline;

    }

    details[open] span.closed {

         display: none;

    }

    </style>

{% endblock stylesheets %}

{% block description %}

{{ repository_name }} {{ commit.hash|truncatechars:10 }}: {{ commit.msg }}

{% endblock description %}

{% block header %}

<header>

    <h1>{{ repository_name }}</h1>  

</header>

{% endblock header %}

{% block main %}

<section class="emphasis">

    <h2>{{ first_line }}</h2>

    <p>{{ other_lines|safe }}</p>

    <dl>

        <dt>{% translate "Author" %}</dt>

        <dd>{{ commit.author.name }}</dd>

        <dt>{% translate "Date" %}</dt>

        <dd>{{ commit.committer_date|date:"DATETIME_FORMAT" }}</dd>

        <dt>{% translate "Hash" %}</dt>

        <dd><samp>{{ commit.hash }}</samp></dd>

        {% if commit.parents|length_is:"1" %}

        <dt>{% translate "Parent" %}</dt>

        {% else %}

        <dt>{% translate "Parents" %}</dt>

        {% endif %}

        {% for parent in commit.parents %}

        <dd><samp><a href="{% url "gitar-commit" repository_name parent %}">

        {{ parent }}

        </a></samp</dd>

        {% endfor %}

        {% if modified_files|length_is:"1" %}

        <dt>{% translate "Modified file" %}</dt>

        {% else %}

        <dt>{% translate "Modified files" %}</dt>

        {% endif %}

        {% for mod_file in modified_files %}

        <dd><a href="#{{ mod_file.path }}">{{ mod_file.path }}</a></dd>

        {% endfor %}

        {#<dt>{% translate "Child" %}</dt>#}

        {# <dd>{{ commit.author_date|date:"DATETIME_FORMAT" }}</dd>#}

        {# Gonna leave the email out for now, don't like email scrapers #}

        {# <dt>{% translate "E-mail" %}</dt> #}

        {# <dl>{{ commit.author.email }}</dl> #}

    </dl>

</section>

{% for mod_file in modified_files %}

<section>

    <h3 id="{{ mod_file.path }}">{{ mod_file.path }} <a href="#{{ mod_file.path }}">¶</a></h3>