gitar

# For now this module only serves one purpose: To make a well structured, nicely

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

            pass

        deleted[number] = line

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

        pass

        #print("NU CONTROLLER.jAVA")

        #print(modified_file.diff_parsed)

        #print(deleted)

    result["rows"] = process_file(

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

    #print(deletions)

    before_count = 1

    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.

            # Look, I'm tired at the time of writing, and this line seems to be

            # kind of a dick so I'm just gonna try catch it and leave it like

            # that for now

            #try: 

                #row["line"] = source_before[before_count]

            #print(len(source_before))

            #print(before_count)

            if before_count == len(source_before):

                row["line"] = source_before[-1]

            else:

                row["line"] = source_before[before_count]

            #except:

                #pass

            before_count += 1

        elif after_count in additions:

            row["type"] = "addition"

            row["new_num"] = after_count

            # Idem for additions[]

            if after_count == len(source_after):

                row["line"] = source_after[-1]

            else:

                row["line"] = source_after[after_count]

            after_count += 1

        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