coala-analyzer / coala

coalib/results/Diff.py

import copy
import difflib

from coalib.results.LineDiff import LineDiff, ConflictError
from coalib.results.SourceRange import SourceRange


class Diff:
    """
    A Diff result represents a difference for one file.
    """

    def __init__(self, file_list):
        """
        Creates an empty diff for the given file.

        :param file_list: The original (unmodified) file as a list of its
                          lines.
        """
        self._changes = {}
        self._file = file_list

The variable file_list does not seem to be defined.

    @classmethod

The variable classmethod does not seem to be defined.

    def from_string_arrays(cls, file_array_1, file_array_2):
        """
        Creates a Diff object from two arrays containing strings.

        If this Diff is applied to the original array, the second array will be
        created.

        :param file_array_1: Original array
        :param file_array_2: Array to compare
        """
        result = cls(file_array_1)

The variable file_array_1 does not seem to be defined.

        matcher = difflib.SequenceMatcher(None, file_array_1, file_array_2)

The variable file_array_2 does not seem to be defined.

        # We use this because its faster (generator) and doesnt yield as much
        # useless information as get_opcodes.
        for change_group in matcher.get_grouped_opcodes(1):
            for (tag,
                 a_index_1,
                 a_index_2,
                 b_index_1,
                 b_index_2) in change_group:

The variable change_group does not seem to be defined.

                if tag == "delete":

The variable tag does not seem to be defined.

                    for index in range(a_index_1+1, a_index_2+1):

The variable a_index_2 does not seem to be defined.

The variable a_index_1 does not seem to be defined.

                        result.delete_line(index)

The variable index does not seem to be defined.

                elif tag == "insert":
                    # We add after line, they add before, so dont add 1 here
                    result.add_lines(a_index_1,
                                     file_array_2[b_index_1:b_index_2])

The variable b_index_2 does not seem to be defined.

The variable b_index_1 does not seem to be defined.

                elif tag == "replace":
                    result.change_line(a_index_1+1,
                                       file_array_1[a_index_1],
                                       file_array_2[b_index_1])
                    result.add_lines(a_index_1+1,
                                     file_array_2[b_index_1+1:b_index_2])
                    for index in range(a_index_1+2, a_index_2+1):
                        result.delete_line(index)

        return result

The variable result does not seem to be defined.

    @classmethod

The variable classmethod does not seem to be defined.

    def from_clang_fixit(cls, fixit, file):
        """
        Creates a Diff object from a given clang fixit and the file contents.

        :param fixit: A cindex.Fixit object.
        :param file:  A list of lines in the file to apply the fixit to.
        :return:      The corresponding Diff object.
        """
        assert isinstance(file, (list, tuple))

The variable list does not seem to be defined.

The variable file does not seem to be defined.

The variable tuple does not seem to be defined.

        oldvalue = '\n'.join(file[fixit.range.start.line-1:

The variable fixit does not seem to be defined.

                                  fixit.range.end.line])
        endindex = fixit.range.end.column - len(file[fixit.range.end.line-1])-1

        newvalue = (oldvalue[:fixit.range.start.column-1] +

The variable oldvalue does not seem to be defined.

                    fixit.value +
                    oldvalue[endindex:])

The variable endindex does not seem to be defined.

        new_file = (file[:fixit.range.start.line-1] +
                    type(file)(newvalue.splitlines(True)) +
                    file[fixit.range.end.line:])

        return cls.from_string_arrays(file, new_file)

The variable new_file does not seem to be defined.

    def _get_change(self, line_nr, min_line=1):
        if not isinstance(line_nr, int):

The variable int does not seem to be defined.

The variable line_nr does not seem to be defined.

            raise TypeError("line_nr needs to be an integer.")
        if line_nr < min_line:
            raise ValueError("The given line number is not allowed.")

        return self._changes.get(line_nr, LineDiff())

    def __len__(self):
        return len(self._changes)

The variable self does not seem to be defined.

    @property

The variable property does not seem to be defined.

    def original(self):
        """
        Retrieves the original file.
        """
        return self._file

The variable self does not seem to be defined.

    @property

The variable property does not seem to be defined.

    def modified(self):
        """
        Calculates the modified file, after applying the Diff to the original.
        """
        result = []
        current_line = 0

        # Note that line_nr counts from _1_ although 0 is possible when
        # inserting lines before everything
        for line_nr in sorted(self._changes):

The variable self does not seem to be defined.

            result.extend(self._file[current_line:max(line_nr-1, 0)])

The variable current_line does not seem to be defined.

The variable line_nr does not seem to be defined.

            linediff = self._changes[line_nr]
            if not linediff.delete and not linediff.change and line_nr > 0:

The variable linediff does not seem to be defined.

                result.append(self._file[line_nr-1])
            elif linediff.change:
                result.append(linediff.change[1])

            if linediff.add_after:
                result.extend(linediff.add_after)

            current_line = line_nr

        result.extend(self._file[current_line:])

        return result

The variable result does not seem to be defined.

    @property

The variable property does not seem to be defined.

    def unified_diff(self):
        """
        Generates a unified diff corresponding to this patch.

        Note that the unified diff is not deterministic and thus not suitable
        for equality comparison.
        """
        return ''.join(difflib.unified_diff(self.original, self.modified))

The variable self does not seem to be defined.

    def __json__(self):
        """
        Override JSON export, using the unified diff is the easiest thing for
        the users.
        """
        return self.unified_diff

The variable self does not seem to be defined.

    def affected_code(self, filename):
        """
        Creates a list of SourceRange objects which point to the related code.
        Changes on continuous lines will be put into one SourceRange.

        :param filename: The filename to associate the SourceRange's to.
        :return:         A list of all related SourceRange objects.
        """
        return list(diff.range(filename) for diff in self.split_diff())

The variable filename does not seem to be defined.

The variable diff does not seem to be defined.

    def split_diff(self):
        """
        Splits this diff into small pieces, such that several continuously
        altered lines are still together in one diff. All subdiffs will be
        yielded.
        """
        diffs = []

        last_line = -1
        this_diff = Diff(self._file)

The variable self does not seem to be defined.

        for line in sorted(self._changes.keys()):
            if line != last_line + 1 and len(this_diff._changes) > 0:

The variable line does not seem to be defined.

The variable this_diff does not seem to be defined.

                yield this_diff
                this_diff = Diff(self._file)

            last_line = line
            this_diff._changes[line] = self._changes[line]

        if len(this_diff._changes) > 0:
            yield this_diff

    def range(self, filename):
        """
        Calculates a SourceRange spanning over the whole Diff. If something is
        added after the 0th line (i.e. before the first line) the first line
        will be included in the SourceRange.

        :param filename: The filename to associate the SourceRange with.
        :return:         A SourceRange object.
        """
        start = min(self._changes.keys())
        end = max(self._changes.keys())
        return SourceRange.from_values(filename,

The variable filename does not seem to be defined.

                                       start_line=max(1, start),

The variable start does not seem to be defined.

                                       end_line=max(1, end))

The variable end does not seem to be defined.

    def __add__(self, other):
        """
        Adds another diff to this one. Will throw an exception if this is not
        possible. (This will *not* be done in place.)
        """
        if not isinstance(other, Diff):

The variable Diff does not seem to be defined.

The variable other does not seem to be defined.

            raise TypeError("Only diffs can be added to a diff.")

        result = copy.deepcopy(self)

The variable self does not seem to be defined.

        for line_nr in other._changes:
            change = other._changes[line_nr]

The variable line_nr does not seem to be defined.

            if change.delete is True:

The variable change does not seem to be defined.

                result.delete_line(line_nr)
            if change.add_after is not False:
                result.add_lines(line_nr, change.add_after)
            if change.change is not False:
                result.change_line(line_nr, change.change[0], change.change[1])

        return result

The variable result does not seem to be defined.

    def delete_line(self, line_nr):
        """
        Mark the given line nr as deleted. The first line is line number 1.
        """
        linediff = self._get_change(line_nr)

The variable line_nr does not seem to be defined.

        linediff.delete = True
        self._changes[line_nr] = linediff

The variable linediff does not seem to be defined.

    def add_lines(self, line_nr_before, lines):
        """
        Adds lines after the given line number.

        :param line_nr_before: Line number of the line before the additions.
                               Use 0 for insert lines before everything.
        :param lines:          A list of lines to add.
        """
        if lines == []:

The variable lines does not seem to be defined.

            return  # No action

        linediff = self._get_change(line_nr_before, min_line=0)

The variable line_nr_before does not seem to be defined.

        if linediff.add_after is not False:

The variable linediff does not seem to be defined.

            raise ConflictError("Cannot add lines after the given line since "
                                "there are already lines.")

        linediff.add_after = lines
        self._changes[line_nr_before] = linediff

    def change_line(self, line_nr, original_line, replacement):
        """
        Changes the given line with the given line number. The replacement will
        be there instead.
        """
        linediff = self._get_change(line_nr)

The variable line_nr does not seem to be defined.

        if linediff.change is not False:

The variable linediff does not seem to be defined.

            raise ConflictError("An already changed line cannot be changed.")

        linediff.change = (original_line, replacement)

The variable original_line does not seem to be defined.

The variable replacement does not seem to be defined.

        self._changes[line_nr] = linediff

    def __eq__(self, other):
        return ((self._file == other._file) and

The variable self does not seem to be defined.

                (self.modified == other.modified))