Diff.__eq__() - Code Metrics - Inspection of "Sils/prerename" - coala-analyzer/coala - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#2132)

by Lasse

created 2016-05-11 18:36 UTC

Diff.eq() A

↳ Parent: Diff.__add__()

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
cc	1
dl	0
loc	3
rs	10

import copy
import difflib

from coalib.results.LineDiff import LineDiff, ConflictError
from coalib.results.SourceRange import SourceRange
from coalib.misc.Decorators import enforce_signature, generate_eq


@generate_eq("_file", "modified", "rename", "delete")
class Diff:
    """
    A Diff result represents a difference for one file.
    """

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

        :param file_list: The original (unmodified) file as a list of its
                          lines.
        :param rename:    False or str containing new name of file.
        :param delete:    True if file is set to be deleted.
        """
        self._changes = {}
        self._file = file_list
        self.rename = rename
        self.delete = delete

    @classmethod
    def from_string_arrays(cls, file_array_1, file_array_2, rename=False):
        """
        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
        :param rename:       False or str containing new name of file.
        """
        result = cls(file_array_1, rename=rename)

        matcher = difflib.SequenceMatcher(None, file_array_1, file_array_2)
        # 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:
                if tag == "delete":
                    for index in range(a_index_1+1, a_index_2+1):
                        result.delete_line(index)
                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])
                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

    @classmethod
    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))

        oldvalue = '\n'.join(file[fixit.range.start.line-1:
                                  fixit.range.end.line])
        endindex = fixit.range.end.column - len(file[fixit.range.end.line-1])-1

        newvalue = (oldvalue[:fixit.range.start.column-1] +
                    fixit.value +
                    oldvalue[endindex:])
        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)

    def _get_change(self, line_nr, min_line=1):
        if not isinstance(line_nr, int):
            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 stats(self):
        """
        Returns tuple containing number of additions and deletions in the diff.
        """
        additions = 0
        deletions = 0
        for line_diff in self._changes.values():
            if line_diff.change:
                additions += 1
                deletions += 1
            elif line_diff.delete:
                deletions += 1
            if line_diff.add_after:
                additions += len(line_diff.add_after)
        return additions, deletions

    def __len__(self):
        """
        Returns total number of additions and deletions in diff.
        """
        return sum(self.stats())

    @property
    def rename(self):
        """
        :return: string containing new name of the file.
        """
        return self._rename

    @rename.setter
    @enforce_signature
    def rename(self, rename: (str, False)):
        """
        :param rename: False or string containing new name of file.
        """
        self._rename = rename

    @property
    def delete(self):
        """
        :return: True if file is set to be deleted.
        """
        return self._delete

    @delete.setter
    @enforce_signature
    def delete(self, delete: bool):
        """
        :param delete: True if file is set to be deleted, False otherwise.
        """
        self._delete = delete

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

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

        if self.delete:
            return 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):
            result.extend(self._file[current_line:max(line_nr-1, 0)])
            linediff = self._changes[line_nr]
            if not linediff.delete and not linediff.change and line_nr > 0:
                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

    @property
    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 if not self.delete else [],
            tofile=self.rename if isinstance(self.rename, str) else ''))

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

    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())

    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.
        """
        last_line = -1
        this_diff = Diff(self._file, rename=self.rename, delete=self.delete)
        for line in sorted(self._changes.keys()):
            if line != last_line + 1 and len(this_diff._changes) > 0:
                yield this_diff
                this_diff = Diff(self._file, rename=self.rename,
                                 delete=self.delete)

            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,
                                       start_line=max(1, start),
                                       end_line=max(1, end))

    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):
            raise TypeError("Only diffs can be added to a diff.")

        if self.rename != other.rename and False not in (self.rename,
                                                         other.rename):
            raise ConflictError("Diffs contain conflicting renamings.")

        result = copy.deepcopy(self)
        result.rename = self.rename or other.rename
        result.delete = self.delete or other.delete

        for line_nr in other._changes:
            change = other._changes[line_nr]
            if change.delete is True:
                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

    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)
        linediff.delete = True
        self._changes[line_nr] = linediff

    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 == []:
            return  # No action

        linediff = self._get_change(line_nr_before, min_line=0)
        if linediff.add_after is not False:
            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)
        if linediff.change is not False:
            raise ConflictError("An already changed line cannot be changed.")

        linediff.change = (original_line, replacement)
        self._changes[line_nr] = linediff


1			import copy
2			import difflib
3
4			from coalib.results.LineDiff import LineDiff, ConflictError
5			from coalib.results.SourceRange import SourceRange
6			from coalib.misc.Decorators import enforce_signature, generate_eq
7
8
9			@generate_eq("_file", "modified", "rename", "delete")
10			class Diff:
11			"""
12			A Diff result represents a difference for one file.
13			"""
14
15			def __init__(self, file_list, rename=False, delete=False):
16			"""
17			Creates an empty diff for the given file.
18
19			:param file_list: The original (unmodified) file as a list of its
20			lines.
21			:param rename: False or str containing new name of file.
22			:param delete: True if file is set to be deleted.
23			"""
24			self._changes = {}
25			self._file = file_list
26			self.rename = rename
27			self.delete = delete
28
29			@classmethod
30			def from_string_arrays(cls, file_array_1, file_array_2, rename=False):
31			"""
32			Creates a Diff object from two arrays containing strings.
33
34			If this Diff is applied to the original array, the second array will be
35			created.
36
37			:param file_array_1: Original array
38			:param file_array_2: Array to compare
39			:param rename: False or str containing new name of file.
40			"""
41			result = cls(file_array_1, rename=rename)
42
43			matcher = difflib.SequenceMatcher(None, file_array_1, file_array_2)
44			# We use this because its faster (generator) and doesnt yield as much
45			# useless information as get_opcodes.
46			for change_group in matcher.get_grouped_opcodes(1):
47			for (tag,
48			a_index_1,
49			a_index_2,
50			b_index_1,
51			b_index_2) in change_group:
52			if tag == "delete":
53			for index in range(a_index_1+1, a_index_2+1):
54			result.delete_line(index)
55			elif tag == "insert":
56			# We add after line, they add before, so dont add 1 here
57			result.add_lines(a_index_1,
58			file_array_2[b_index_1:b_index_2])
59			elif tag == "replace":
60			result.change_line(a_index_1+1,
61			file_array_1[a_index_1],
62			file_array_2[b_index_1])
63			result.add_lines(a_index_1+1,
64			file_array_2[b_index_1+1:b_index_2])
65			for index in range(a_index_1+2, a_index_2+1):
66			result.delete_line(index)
67
68			return result
69
70			@classmethod
71			def from_clang_fixit(cls, fixit, file):
72			"""
73			Creates a Diff object from a given clang fixit and the file contents.
74
75			:param fixit: A cindex.Fixit object.
76			:param file: A list of lines in the file to apply the fixit to.
77			:return: The corresponding Diff object.
78			"""
79			assert isinstance(file, (list, tuple))
80
81			oldvalue = '\n'.join(file[fixit.range.start.line-1:
82			fixit.range.end.line])
83			endindex = fixit.range.end.column - len(file[fixit.range.end.line-1])-1
84
85			newvalue = (oldvalue[:fixit.range.start.column-1] +
86			fixit.value +
87			oldvalue[endindex:])
88			new_file = (file[:fixit.range.start.line-1] +
89			type(file)(newvalue.splitlines(True)) +
90			file[fixit.range.end.line:])
91
92			return cls.from_string_arrays(file, new_file)
93
94			def _get_change(self, line_nr, min_line=1):
95			if not isinstance(line_nr, int):
96			raise TypeError("line_nr needs to be an integer.")
97			if line_nr < min_line:
98			raise ValueError("The given line number is not allowed.")
99
100			return self._changes.get(line_nr, LineDiff())
101
102			def stats(self):
103			"""
104			Returns tuple containing number of additions and deletions in the diff.
105			"""
106			additions = 0
107			deletions = 0
108			for line_diff in self._changes.values():
109			if line_diff.change:
110			additions += 1
111			deletions += 1
112			elif line_diff.delete:
113			deletions += 1
114			if line_diff.add_after:
115			additions += len(line_diff.add_after)
116			return additions, deletions
117
118			def __len__(self):
119			"""
120			Returns total number of additions and deletions in diff.
121			"""
122			return sum(self.stats())
123
124			@property
125			def rename(self):
126			"""
127			:return: string containing new name of the file.
128			"""
129			return self._rename
130
131			@rename.setter
132			@enforce_signature
133			def rename(self, rename: (str, False)):
134			"""
135			:param rename: False or string containing new name of file.
136			"""
137			self._rename = rename
138
139			@property
140			def delete(self):
141			"""
142			:return: True if file is set to be deleted.
143			"""
144			return self._delete
145
146			@delete.setter
147			@enforce_signature
148			def delete(self, delete: bool):
149			"""
150			:param delete: True if file is set to be deleted, False otherwise.
151			"""
152			self._delete = delete
153
154			@property
155			def original(self):
156			"""
157			Retrieves the original file.
158			"""
159			return self._file
160
161			@property
162			def modified(self):
163			"""
164			Calculates the modified file, after applying the Diff to the original.
165			"""
166			result = []
167
168			if self.delete:
169			return result
170
171			current_line = 0
172
173			# Note that line_nr counts from _1_ although 0 is possible when
174			# inserting lines before everything
175			for line_nr in sorted(self._changes):
176			result.extend(self._file[current_line:max(line_nr-1, 0)])
177			linediff = self._changes[line_nr]
178			if not linediff.delete and not linediff.change and line_nr > 0:
179			result.append(self._file[line_nr-1])
180			elif linediff.change:
181			result.append(linediff.change[1])
182
183			if linediff.add_after:
184			result.extend(linediff.add_after)
185
186			current_line = line_nr
187
188			result.extend(self._file[current_line:])
189
190			return result
191
192			@property
193			def unified_diff(self):
194			"""
195			Generates a unified diff corresponding to this patch.
196
197			Note that the unified diff is not deterministic and thus not suitable
198			for equality comparison.
199			"""
200			return ''.join(difflib.unified_diff(
201			self.original,
202			self.modified if not self.delete else [],
203			tofile=self.rename if isinstance(self.rename, str) else ''))
204
205			def __json__(self):
206			"""
207			Override JSON export, using the unified diff is the easiest thing for
208			the users.
209			"""
210			return self.unified_diff
211
212			def affected_code(self, filename):
213			"""
214			Creates a list of SourceRange objects which point to the related code.
215			Changes on continuous lines will be put into one SourceRange.
216
217			:param filename: The filename to associate the SourceRange's to.
218			:return: A list of all related SourceRange objects.
219			"""
220			return list(diff.range(filename) for diff in self.split_diff())
221
222			def split_diff(self):
223			"""
224			Splits this diff into small pieces, such that several continuously
225			altered lines are still together in one diff. All subdiffs will be
226			yielded.
227			"""
228			last_line = -1
229			this_diff = Diff(self._file, rename=self.rename, delete=self.delete)
230			for line in sorted(self._changes.keys()):
231			if line != last_line + 1 and len(this_diff._changes) > 0:
232			yield this_diff
233			this_diff = Diff(self._file, rename=self.rename,
234			delete=self.delete)
235
236			last_line = line
237			this_diff._changes[line] = self._changes[line]
238
239			if len(this_diff._changes) > 0:
240			yield this_diff
241
242			def range(self, filename):
243			"""
244			Calculates a SourceRange spanning over the whole Diff. If something is
245			added after the 0th line (i.e. before the first line) the first line
246			will be included in the SourceRange.
247
248			:param filename: The filename to associate the SourceRange with.
249			:return: A SourceRange object.
250			"""
251			start = min(self._changes.keys())
252			end = max(self._changes.keys())
253			return SourceRange.from_values(filename,
254			start_line=max(1, start),
255			end_line=max(1, end))
256
257			def __add__(self, other):
258			"""
259			Adds another diff to this one. Will throw an exception if this is not
260			possible. (This will not be done in place.)
261			"""
262			if not isinstance(other, Diff):
263			raise TypeError("Only diffs can be added to a diff.")
264
265			if self.rename != other.rename and False not in (self.rename,
266			other.rename):
267			raise ConflictError("Diffs contain conflicting renamings.")
268
269			result = copy.deepcopy(self)
270			result.rename = self.rename or other.rename
271			result.delete = self.delete or other.delete
272
273			for line_nr in other._changes:
274			change = other._changes[line_nr]
275			if change.delete is True:
276			result.delete_line(line_nr)
277			if change.add_after is not False:
278			result.add_lines(line_nr, change.add_after)
279			if change.change is not False:
280			result.change_line(line_nr, change.change[0], change.change[1])
281
282			return result
283
284			def delete_line(self, line_nr):
285			"""
286			Mark the given line nr as deleted. The first line is line number 1.
287			"""
288			linediff = self._get_change(line_nr)
289			linediff.delete = True
290			self._changes[line_nr] = linediff
291
292			def add_lines(self, line_nr_before, lines):
293			"""
294			Adds lines after the given line number.
295
296			:param line_nr_before: Line number of the line before the additions.
297			Use 0 for insert lines before everything.
298			:param lines: A list of lines to add.
299			"""
300			if lines == []:
301			return # No action
302
303			linediff = self._get_change(line_nr_before, min_line=0)
304			if linediff.add_after is not False:
305			raise ConflictError("Cannot add lines after the given line since "
306			"there are already lines.")
307
308			linediff.add_after = lines
309			self._changes[line_nr_before] = linediff
310
311			def change_line(self, line_nr, original_line, replacement):
312			"""
313			Changes the given line with the given line number. The replacement will
314			be there instead.
315			"""
316			linediff = self._get_change(line_nr)
317			if linediff.change is not False:
318			raise ConflictError("An already changed line cannot be changed.")
319
320			linediff.change = (original_line, replacement)
321			self._changes[line_nr] = linediff
322

coala-analyzer / coala

Pull Request — master (#2132)

Diff.__eq__() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like

Diff.eq() A