diff --git a/rhodecode/lib/diff_match_patch.py b/rhodecode/lib/diff_match_patch.py --- a/rhodecode/lib/diff_match_patch.py +++ b/rhodecode/lib/diff_match_patch.py @@ -1,6 +1,3 @@ - - - """Diff Match and Patch Copyright 2006 Google Inc. @@ -25,7 +22,7 @@ Computes the difference between two text Applies the patch onto another text, allowing for errors. """ -__author__ = 'fraser@google.com (Neil Fraser)' +__author__ = "fraser@google.com (Neil Fraser)" import math import re @@ -35,1885 +32,2000 @@ import urllib.request, urllib.parse, url class diff_match_patch: - """Class containing the diff, match and patch methods. - - Also contains the behaviour settings. - """ - - def __init__(self): - """Inits a diff_match_patch object with default settings. - Redefine these in your program to override the defaults. - """ - - # Number of seconds to map a diff before giving up (0 for infinity). - self.Diff_Timeout = 1.0 - # Cost of an empty edit operation in terms of edit characters. - self.Diff_EditCost = 4 - # At what point is no match declared (0.0 = perfection, 1.0 = very loose). - self.Match_Threshold = 0.5 - # How far to search for a match (0 = exact location, 1000+ = broad match). - # A match this many characters away from the expected location will add - # 1.0 to the score (0.0 is a perfect match). - self.Match_Distance = 1000 - # When deleting a large block of text (over ~64 characters), how close do - # the contents have to be to match the expected contents. (0.0 = perfection, - # 1.0 = very loose). Note that Match_Threshold controls how closely the - # end points of a delete need to match. - self.Patch_DeleteThreshold = 0.5 - # Chunk size for context length. - self.Patch_Margin = 4 - - # The number of bits in an int. - # Python has no maximum, thus to disable patch splitting set to 0. - # However to avoid long patches in certain pathological cases, use 32. - # Multiple short patches (using native ints) are much faster than long ones. - self.Match_MaxBits = 32 - - # DIFF FUNCTIONS - - # The data structure representing a diff is an array of tuples: - # [(DIFF_DELETE, "Hello"), (DIFF_INSERT, "Goodbye"), (DIFF_EQUAL, " world.")] - # which means: delete "Hello", add "Goodbye" and keep " world." - DIFF_DELETE = -1 - DIFF_INSERT = 1 - DIFF_EQUAL = 0 - - def diff_main(self, text1, text2, checklines=True, deadline=None): - """Find the differences between two texts. Simplifies the problem by - stripping any common prefix or suffix off the texts before diffing. - - Args: - text1: Old string to be diffed. - text2: New string to be diffed. - checklines: Optional speedup flag. If present and false, then don't run - a line-level diff first to identify the changed areas. - Defaults to true, which does a faster, slightly less optimal diff. - deadline: Optional time when the diff should be complete by. Used - internally for recursive calls. Users should set DiffTimeout instead. - - Returns: - Array of changes. - """ - # Set a deadline by which time the diff must be complete. - if deadline is None: - # Unlike in most languages, Python counts time in seconds. - if self.Diff_Timeout <= 0: - deadline = sys.maxint - else: - deadline = time.time() + self.Diff_Timeout - - # Check for null inputs. - if text1 is None or text2 is None: - raise ValueError("Null inputs. (diff_main)") - - # Check for equality (speedup). - if text1 == text2: - if text1: - return [(self.DIFF_EQUAL, text1)] - return [] - - # Trim off common prefix (speedup). - commonlength = self.diff_commonPrefix(text1, text2) - commonprefix = text1[:commonlength] - text1 = text1[commonlength:] - text2 = text2[commonlength:] - - # Trim off common suffix (speedup). - commonlength = self.diff_commonSuffix(text1, text2) - if commonlength == 0: - commonsuffix = '' - else: - commonsuffix = text1[-commonlength:] - text1 = text1[:-commonlength] - text2 = text2[:-commonlength] - - # Compute the diff on the middle block. - diffs = self.diff_compute(text1, text2, checklines, deadline) - - # Restore the prefix and suffix. - if commonprefix: - diffs[:0] = [(self.DIFF_EQUAL, commonprefix)] - if commonsuffix: - diffs.append((self.DIFF_EQUAL, commonsuffix)) - self.diff_cleanupMerge(diffs) - return diffs - - def diff_compute(self, text1, text2, checklines, deadline): - """Find the differences between two texts. Assumes that the texts do not - have any common prefix or suffix. - - Args: - text1: Old string to be diffed. - text2: New string to be diffed. - checklines: Speedup flag. If false, then don't run a line-level diff - first to identify the changed areas. - If true, then run a faster, slightly less optimal diff. - deadline: Time when the diff should be complete by. - - Returns: - Array of changes. - """ - if not text1: - # Just add some text (speedup). - return [(self.DIFF_INSERT, text2)] - - if not text2: - # Just delete some text (speedup). - return [(self.DIFF_DELETE, text1)] - - if len(text1) > len(text2): - (longtext, shorttext) = (text1, text2) - else: - (shorttext, longtext) = (text1, text2) - i = longtext.find(shorttext) - if i != -1: - # Shorter text is inside the longer text (speedup). - diffs = [(self.DIFF_INSERT, longtext[:i]), (self.DIFF_EQUAL, shorttext), - (self.DIFF_INSERT, longtext[i + len(shorttext):])] - # Swap insertions for deletions if diff is reversed. - if len(text1) > len(text2): - diffs[0] = (self.DIFF_DELETE, diffs[0][1]) - diffs[2] = (self.DIFF_DELETE, diffs[2][1]) - return diffs - - if len(shorttext) == 1: - # Single character string. - # After the previous speedup, the character can't be an equality. - return [(self.DIFF_DELETE, text1), (self.DIFF_INSERT, text2)] - - # Check to see if the problem can be split in two. - hm = self.diff_halfMatch(text1, text2) - if hm: - # A half-match was found, sort out the return data. - (text1_a, text1_b, text2_a, text2_b, mid_common) = hm - # Send both pairs off for separate processing. - diffs_a = self.diff_main(text1_a, text2_a, checklines, deadline) - diffs_b = self.diff_main(text1_b, text2_b, checklines, deadline) - # Merge the results. - return diffs_a + [(self.DIFF_EQUAL, mid_common)] + diffs_b - - if checklines and len(text1) > 100 and len(text2) > 100: - return self.diff_lineMode(text1, text2, deadline) - - return self.diff_bisect(text1, text2, deadline) - - def diff_lineMode(self, text1, text2, deadline): - """Do a quick line-level diff on both strings, then rediff the parts for - greater accuracy. - This speedup can produce non-minimal diffs. - - Args: - text1: Old string to be diffed. - text2: New string to be diffed. - deadline: Time when the diff should be complete by. - - Returns: - Array of changes. - """ - - # Scan the text on a line-by-line basis first. - (text1, text2, linearray) = self.diff_linesToChars(text1, text2) - - diffs = self.diff_main(text1, text2, False, deadline) - - # Convert the diff back to original text. - self.diff_charsToLines(diffs, linearray) - # Eliminate freak matches (e.g. blank lines) - self.diff_cleanupSemantic(diffs) - - # Rediff any replacement blocks, this time character-by-character. - # Add a dummy entry at the end. - diffs.append((self.DIFF_EQUAL, '')) - pointer = 0 - count_delete = 0 - count_insert = 0 - text_delete = '' - text_insert = '' - while pointer < len(diffs): - if diffs[pointer][0] == self.DIFF_INSERT: - count_insert += 1 - text_insert += diffs[pointer][1] - elif diffs[pointer][0] == self.DIFF_DELETE: - count_delete += 1 - text_delete += diffs[pointer][1] - elif diffs[pointer][0] == self.DIFF_EQUAL: - # Upon reaching an equality, check for prior redundancies. - if count_delete >= 1 and count_insert >= 1: - # Delete the offending records and add the merged ones. - a = self.diff_main(text_delete, text_insert, False, deadline) - diffs[pointer - count_delete - count_insert : pointer] = a - pointer = pointer - count_delete - count_insert + len(a) - count_insert = 0 - count_delete = 0 - text_delete = '' - text_insert = '' - - pointer += 1 - - diffs.pop() # Remove the dummy entry at the end. - - return diffs - - def diff_bisect(self, text1, text2, deadline): - """Find the 'middle snake' of a diff, split the problem in two - and return the recursively constructed diff. - See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations. - - Args: - text1: Old string to be diffed. - text2: New string to be diffed. - deadline: Time at which to bail if not yet complete. - - Returns: - Array of diff tuples. - """ - - # Cache the text lengths to prevent multiple calls. - text1_length = len(text1) - text2_length = len(text2) - max_d = (text1_length + text2_length + 1) // 2 - v_offset = max_d - v_length = 2 * max_d - v1 = [-1] * v_length - v1[v_offset + 1] = 0 - v2 = v1[:] - delta = text1_length - text2_length - # If the total number of characters is odd, then the front path will - # collide with the reverse path. - front = (delta % 2 != 0) - # Offsets for start and end of k loop. - # Prevents mapping of space beyond the grid. - k1start = 0 - k1end = 0 - k2start = 0 - k2end = 0 - for d in range(max_d): - # Bail out if deadline is reached. - if time.time() > deadline: - break - - # Walk the front path one step. - for k1 in range(-d + k1start, d + 1 - k1end, 2): - k1_offset = v_offset + k1 - if k1 == -d or (k1 != d and - v1[k1_offset - 1] < v1[k1_offset + 1]): - x1 = v1[k1_offset + 1] - else: - x1 = v1[k1_offset - 1] + 1 - y1 = x1 - k1 - while (x1 < text1_length and y1 < text2_length and - text1[x1] == text2[y1]): - x1 += 1 - y1 += 1 - v1[k1_offset] = x1 - if x1 > text1_length: - # Ran off the right of the graph. - k1end += 2 - elif y1 > text2_length: - # Ran off the bottom of the graph. - k1start += 2 - elif front: - k2_offset = v_offset + delta - k1 - if k2_offset >= 0 and k2_offset < v_length and v2[k2_offset] != -1: - # Mirror x2 onto top-left coordinate system. - x2 = text1_length - v2[k2_offset] - if x1 >= x2: - # Overlap detected. - return self.diff_bisectSplit(text1, text2, x1, y1, deadline) - - # Walk the reverse path one step. - for k2 in range(-d + k2start, d + 1 - k2end, 2): - k2_offset = v_offset + k2 - if k2 == -d or (k2 != d and - v2[k2_offset - 1] < v2[k2_offset + 1]): - x2 = v2[k2_offset + 1] - else: - x2 = v2[k2_offset - 1] + 1 - y2 = x2 - k2 - while (x2 < text1_length and y2 < text2_length and - text1[-x2 - 1] == text2[-y2 - 1]): - x2 += 1 - y2 += 1 - v2[k2_offset] = x2 - if x2 > text1_length: - # Ran off the left of the graph. - k2end += 2 - elif y2 > text2_length: - # Ran off the top of the graph. - k2start += 2 - elif not front: - k1_offset = v_offset + delta - k2 - if k1_offset >= 0 and k1_offset < v_length and v1[k1_offset] != -1: - x1 = v1[k1_offset] - y1 = v_offset + x1 - k1_offset - # Mirror x2 onto top-left coordinate system. - x2 = text1_length - x2 - if x1 >= x2: - # Overlap detected. - return self.diff_bisectSplit(text1, text2, x1, y1, deadline) - - # Diff took too long and hit the deadline or - # number of diffs equals number of characters, no commonality at all. - return [(self.DIFF_DELETE, text1), (self.DIFF_INSERT, text2)] - - def diff_bisectSplit(self, text1, text2, x, y, deadline): - """Given the location of the 'middle snake', split the diff in two parts - and recurse. - - Args: - text1: Old string to be diffed. - text2: New string to be diffed. - x: Index of split point in text1. - y: Index of split point in text2. - deadline: Time at which to bail if not yet complete. - - Returns: - Array of diff tuples. - """ - text1a = text1[:x] - text2a = text2[:y] - text1b = text1[x:] - text2b = text2[y:] - - # Compute both diffs serially. - diffs = self.diff_main(text1a, text2a, False, deadline) - diffsb = self.diff_main(text1b, text2b, False, deadline) - - return diffs + diffsb - - def diff_linesToChars(self, text1, text2): - """Split two texts into an array of strings. Reduce the texts to a string - of hashes where each Unicode character represents one line. + """Class containing the diff, match and patch methods. - Args: - text1: First string. - text2: Second string. - - Returns: - Three element tuple, containing the encoded text1, the encoded text2 and - the array of unique strings. The zeroth element of the array of unique - strings is intentionally blank. - """ - lineArray = [] # e.g. lineArray[4] == "Hello\n" - lineHash = {} # e.g. lineHash["Hello\n"] == 4 - - # "\x00" is a valid character, but various debuggers don't like it. - # So we'll insert a junk entry to avoid generating a null character. - lineArray.append('') - - def diff_linesToCharsMunge(text): - """Split a text into an array of strings. Reduce the texts to a string - of hashes where each Unicode character represents one line. - Modifies linearray and linehash through being a closure. - - Args: - text: String to encode. - - Returns: - Encoded string. - """ - chars = [] - # Walk the text, pulling out a substring for each line. - # text.split('\n') would would temporarily double our memory footprint. - # Modifying text would create many large strings to garbage collect. - lineStart = 0 - lineEnd = -1 - while lineEnd < len(text) - 1: - lineEnd = text.find('\n', lineStart) - if lineEnd == -1: - lineEnd = len(text) - 1 - line = text[lineStart:lineEnd + 1] - lineStart = lineEnd + 1 - - if line in lineHash: - chars.append(unichr(lineHash[line])) - else: - lineArray.append(line) - lineHash[line] = len(lineArray) - 1 - chars.append(unichr(len(lineArray) - 1)) - return "".join(chars) - - chars1 = diff_linesToCharsMunge(text1) - chars2 = diff_linesToCharsMunge(text2) - return (chars1, chars2, lineArray) - - def diff_charsToLines(self, diffs, lineArray): - """Rehydrate the text in a diff from a string of line hashes to real lines - of text. - - Args: - diffs: Array of diff tuples. - lineArray: Array of unique strings. - """ - for x in range(len(diffs)): - text = [] - for char in diffs[x][1]: - text.append(lineArray[ord(char)]) - diffs[x] = (diffs[x][0], "".join(text)) - - def diff_commonPrefix(self, text1, text2): - """Determine the common prefix of two strings. - - Args: - text1: First string. - text2: Second string. - - Returns: - The number of characters common to the start of each string. - """ - # Quick check for common null cases. - if not text1 or not text2 or text1[0] != text2[0]: - return 0 - # Binary search. - # Performance analysis: http://neil.fraser.name/news/2007/10/09/ - pointermin = 0 - pointermax = min(len(text1), len(text2)) - pointermid = pointermax - pointerstart = 0 - while pointermin < pointermid: - if text1[pointerstart:pointermid] == text2[pointerstart:pointermid]: - pointermin = pointermid - pointerstart = pointermin - else: - pointermax = pointermid - pointermid = (pointermax - pointermin) // 2 + pointermin - return pointermid - - def diff_commonSuffix(self, text1, text2): - """Determine the common suffix of two strings. - - Args: - text1: First string. - text2: Second string. - - Returns: - The number of characters common to the end of each string. - """ - # Quick check for common null cases. - if not text1 or not text2 or text1[-1] != text2[-1]: - return 0 - # Binary search. - # Performance analysis: http://neil.fraser.name/news/2007/10/09/ - pointermin = 0 - pointermax = min(len(text1), len(text2)) - pointermid = pointermax - pointerend = 0 - while pointermin < pointermid: - if (text1[-pointermid:len(text1) - pointerend] == - text2[-pointermid:len(text2) - pointerend]): - pointermin = pointermid - pointerend = pointermin - else: - pointermax = pointermid - pointermid = (pointermax - pointermin) // 2 + pointermin - return pointermid - - def diff_commonOverlap(self, text1, text2): - """Determine if the suffix of one string is the prefix of another. - - Args: - text1 First string. - text2 Second string. - - Returns: - The number of characters common to the end of the first - string and the start of the second string. - """ - # Cache the text lengths to prevent multiple calls. - text1_length = len(text1) - text2_length = len(text2) - # Eliminate the null case. - if text1_length == 0 or text2_length == 0: - return 0 - # Truncate the longer string. - if text1_length > text2_length: - text1 = text1[-text2_length:] - elif text1_length < text2_length: - text2 = text2[:text1_length] - text_length = min(text1_length, text2_length) - # Quick check for the worst case. - if text1 == text2: - return text_length - - # Start by looking for a single character match - # and increase length until no match is found. - # Performance analysis: http://neil.fraser.name/news/2010/11/04/ - best = 0 - length = 1 - while True: - pattern = text1[-length:] - found = text2.find(pattern) - if found == -1: - return best - length += found - if found == 0 or text1[-length:] == text2[:length]: - best = length - length += 1 - - def diff_halfMatch(self, text1, text2): - """Do the two texts share a substring which is at least half the length of - the longer text? - This speedup can produce non-minimal diffs. - - Args: - text1: First string. - text2: Second string. - - Returns: - Five element Array, containing the prefix of text1, the suffix of text1, - the prefix of text2, the suffix of text2 and the common middle. Or None - if there was no match. - """ - if self.Diff_Timeout <= 0: - # Don't risk returning a non-optimal diff if we have unlimited time. - return None - if len(text1) > len(text2): - (longtext, shorttext) = (text1, text2) - else: - (shorttext, longtext) = (text1, text2) - if len(longtext) < 4 or len(shorttext) * 2 < len(longtext): - return None # Pointless. - - def diff_halfMatchI(longtext, shorttext, i): - """Does a substring of shorttext exist within longtext such that the - substring is at least half the length of longtext? - Closure, but does not reference any external variables. - - Args: - longtext: Longer string. - shorttext: Shorter string. - i: Start index of quarter length substring within longtext. - - Returns: - Five element Array, containing the prefix of longtext, the suffix of - longtext, the prefix of shorttext, the suffix of shorttext and the - common middle. Or None if there was no match. - """ - seed = longtext[i:i + len(longtext) // 4] - best_common = '' - j = shorttext.find(seed) - while j != -1: - prefixLength = self.diff_commonPrefix(longtext[i:], shorttext[j:]) - suffixLength = self.diff_commonSuffix(longtext[:i], shorttext[:j]) - if len(best_common) < suffixLength + prefixLength: - best_common = (shorttext[j - suffixLength:j] + - shorttext[j:j + prefixLength]) - best_longtext_a = longtext[:i - suffixLength] - best_longtext_b = longtext[i + prefixLength:] - best_shorttext_a = shorttext[:j - suffixLength] - best_shorttext_b = shorttext[j + prefixLength:] - j = shorttext.find(seed, j + 1) - - if len(best_common) * 2 >= len(longtext): - return (best_longtext_a, best_longtext_b, - best_shorttext_a, best_shorttext_b, best_common) - else: - return None - - # First check if the second quarter is the seed for a half-match. - hm1 = diff_halfMatchI(longtext, shorttext, (len(longtext) + 3) // 4) - # Check again based on the third quarter. - hm2 = diff_halfMatchI(longtext, shorttext, (len(longtext) + 1) // 2) - if not hm1 and not hm2: - return None - elif not hm2: - hm = hm1 - elif not hm1: - hm = hm2 - else: - # Both matched. Select the longest. - if len(hm1[4]) > len(hm2[4]): - hm = hm1 - else: - hm = hm2 - - # A half-match was found, sort out the return data. - if len(text1) > len(text2): - (text1_a, text1_b, text2_a, text2_b, mid_common) = hm - else: - (text2_a, text2_b, text1_a, text1_b, mid_common) = hm - return (text1_a, text1_b, text2_a, text2_b, mid_common) - - def diff_cleanupSemantic(self, diffs): - """Reduce the number of edits by eliminating semantically trivial - equalities. - - Args: - diffs: Array of diff tuples. - """ - changes = False - equalities = [] # Stack of indices where equalities are found. - lastequality = None # Always equal to diffs[equalities[-1]][1] - pointer = 0 # Index of current position. - # Number of chars that changed prior to the equality. - length_insertions1, length_deletions1 = 0, 0 - # Number of chars that changed after the equality. - length_insertions2, length_deletions2 = 0, 0 - while pointer < len(diffs): - if diffs[pointer][0] == self.DIFF_EQUAL: # Equality found. - equalities.append(pointer) - length_insertions1, length_insertions2 = length_insertions2, 0 - length_deletions1, length_deletions2 = length_deletions2, 0 - lastequality = diffs[pointer][1] - else: # An insertion or deletion. - if diffs[pointer][0] == self.DIFF_INSERT: - length_insertions2 += len(diffs[pointer][1]) - else: - length_deletions2 += len(diffs[pointer][1]) - # Eliminate an equality that is smaller or equal to the edits on both - # sides of it. - if (lastequality and (len(lastequality) <= - max(length_insertions1, length_deletions1)) and - (len(lastequality) <= max(length_insertions2, length_deletions2))): - # Duplicate record. - diffs.insert(equalities[-1], (self.DIFF_DELETE, lastequality)) - # Change second copy to insert. - diffs[equalities[-1] + 1] = (self.DIFF_INSERT, - diffs[equalities[-1] + 1][1]) - # Throw away the equality we just deleted. - equalities.pop() - # Throw away the previous equality (it needs to be reevaluated). - if len(equalities): - equalities.pop() - if len(equalities): - pointer = equalities[-1] - else: - pointer = -1 - # Reset the counters. - length_insertions1, length_deletions1 = 0, 0 - length_insertions2, length_deletions2 = 0, 0 - lastequality = None - changes = True - pointer += 1 - - # Normalize the diff. - if changes: - self.diff_cleanupMerge(diffs) - self.diff_cleanupSemanticLossless(diffs) - - # Find any overlaps between deletions and insertions. - # e.g: abcxxxxxxdef - # -> abcxxxdef - # e.g: xxxabcdefxxx - # -> defxxxabc - # Only extract an overlap if it is as big as the edit ahead or behind it. - pointer = 1 - while pointer < len(diffs): - if (diffs[pointer - 1][0] == self.DIFF_DELETE and - diffs[pointer][0] == self.DIFF_INSERT): - deletion = diffs[pointer - 1][1] - insertion = diffs[pointer][1] - overlap_length1 = self.diff_commonOverlap(deletion, insertion) - overlap_length2 = self.diff_commonOverlap(insertion, deletion) - if overlap_length1 >= overlap_length2: - if (overlap_length1 >= len(deletion) / 2.0 or - overlap_length1 >= len(insertion) / 2.0): - # Overlap found. Insert an equality and trim the surrounding edits. - diffs.insert(pointer, (self.DIFF_EQUAL, - insertion[:overlap_length1])) - diffs[pointer - 1] = (self.DIFF_DELETE, - deletion[:len(deletion) - overlap_length1]) - diffs[pointer + 1] = (self.DIFF_INSERT, - insertion[overlap_length1:]) - pointer += 1 - else: - if (overlap_length2 >= len(deletion) / 2.0 or - overlap_length2 >= len(insertion) / 2.0): - # Reverse overlap found. - # Insert an equality and swap and trim the surrounding edits. - diffs.insert(pointer, (self.DIFF_EQUAL, deletion[:overlap_length2])) - diffs[pointer - 1] = (self.DIFF_INSERT, - insertion[:len(insertion) - overlap_length2]) - diffs[pointer + 1] = (self.DIFF_DELETE, deletion[overlap_length2:]) - pointer += 1 - pointer += 1 - pointer += 1 - - def diff_cleanupSemanticLossless(self, diffs): - """Look for single edits surrounded on both sides by equalities - which can be shifted sideways to align the edit to a word boundary. - e.g: The cat came. -> The cat came. - - Args: - diffs: Array of diff tuples. + Also contains the behaviour settings. """ - def diff_cleanupSemanticScore(one, two): - """Given two strings, compute a score representing whether the - internal boundary falls on logical boundaries. - Scores range from 6 (best) to 0 (worst). - Closure, but does not reference any external variables. + def __init__(self): + """Inits a diff_match_patch object with default settings. + Redefine these in your program to override the defaults. + """ + + # Number of seconds to map a diff before giving up (0 for infinity). + self.Diff_Timeout = 1.0 + # Cost of an empty edit operation in terms of edit characters. + self.Diff_EditCost = 4 + # At what point is no match declared (0.0 = perfection, 1.0 = very loose). + self.Match_Threshold = 0.5 + # How far to search for a match (0 = exact location, 1000+ = broad match). + # A match this many characters away from the expected location will add + # 1.0 to the score (0.0 is a perfect match). + self.Match_Distance = 1000 + # When deleting a large block of text (over ~64 characters), how close do + # the contents have to be to match the expected contents. (0.0 = perfection, + # 1.0 = very loose). Note that Match_Threshold controls how closely the + # end points of a delete need to match. + self.Patch_DeleteThreshold = 0.5 + # Chunk size for context length. + self.Patch_Margin = 4 + + # The number of bits in an int. + # Python has no maximum, thus to disable patch splitting set to 0. + # However to avoid long patches in certain pathological cases, use 32. + # Multiple short patches (using native ints) are much faster than long ones. + self.Match_MaxBits = 32 + + # DIFF FUNCTIONS - Args: - one: First string. - two: Second string. + # The data structure representing a diff is an array of tuples: + # [(DIFF_DELETE, "Hello"), (DIFF_INSERT, "Goodbye"), (DIFF_EQUAL, " world.")] + # which means: delete "Hello", add "Goodbye" and keep " world." + DIFF_DELETE = -1 + DIFF_INSERT = 1 + DIFF_EQUAL = 0 + + def diff_main(self, text1, text2, checklines=True, deadline=None): + """Find the differences between two texts. Simplifies the problem by + stripping any common prefix or suffix off the texts before diffing. + + Args: + text1: Old string to be diffed. + text2: New string to be diffed. + checklines: Optional speedup flag. If present and false, then don't run + a line-level diff first to identify the changed areas. + Defaults to true, which does a faster, slightly less optimal diff. + deadline: Optional time when the diff should be complete by. Used + internally for recursive calls. Users should set DiffTimeout instead. + + Returns: + Array of changes. + """ + # Set a deadline by which time the diff must be complete. + if deadline is None: + # Unlike in most languages, Python counts time in seconds. + if self.Diff_Timeout <= 0: + deadline = sys.maxsize + else: + deadline = time.time() + self.Diff_Timeout + + # Check for null inputs. + if text1 is None or text2 is None: + raise ValueError("Null inputs. (diff_main)") - Returns: - The score. - """ - if not one or not two: - # Edges are the best. - return 6 + # Check for equality (speedup). + if text1 == text2: + if text1: + return [(self.DIFF_EQUAL, text1)] + return [] + + # Trim off common prefix (speedup). + commonlength = self.diff_commonPrefix(text1, text2) + commonprefix = text1[:commonlength] + text1 = text1[commonlength:] + text2 = text2[commonlength:] + + # Trim off common suffix (speedup). + commonlength = self.diff_commonSuffix(text1, text2) + if commonlength == 0: + commonsuffix = "" + else: + commonsuffix = text1[-commonlength:] + text1 = text1[:-commonlength] + text2 = text2[:-commonlength] + + # Compute the diff on the middle block. + diffs = self.diff_compute(text1, text2, checklines, deadline) + + # Restore the prefix and suffix. + if commonprefix: + diffs[:0] = [(self.DIFF_EQUAL, commonprefix)] + if commonsuffix: + diffs.append((self.DIFF_EQUAL, commonsuffix)) + self.diff_cleanupMerge(diffs) + return diffs + + def diff_compute(self, text1, text2, checklines, deadline): + """Find the differences between two texts. Assumes that the texts do not + have any common prefix or suffix. - # Each port of this function behaves slightly differently due to - # subtle differences in each language's definition of things like - # 'whitespace'. Since this function's purpose is largely cosmetic, - # the choice has been made to use each language's native features - # rather than force total conformity. - char1 = one[-1] - char2 = two[0] - nonAlphaNumeric1 = not char1.isalnum() - nonAlphaNumeric2 = not char2.isalnum() - whitespace1 = nonAlphaNumeric1 and char1.isspace() - whitespace2 = nonAlphaNumeric2 and char2.isspace() - lineBreak1 = whitespace1 and (char1 == "\r" or char1 == "\n") - lineBreak2 = whitespace2 and (char2 == "\r" or char2 == "\n") - blankLine1 = lineBreak1 and self.BLANKLINEEND.search(one) - blankLine2 = lineBreak2 and self.BLANKLINESTART.match(two) + Args: + text1: Old string to be diffed. + text2: New string to be diffed. + checklines: Speedup flag. If false, then don't run a line-level diff + first to identify the changed areas. + If true, then run a faster, slightly less optimal diff. + deadline: Time when the diff should be complete by. + + Returns: + Array of changes. + """ + if not text1: + # Just add some text (speedup). + return [(self.DIFF_INSERT, text2)] + + if not text2: + # Just delete some text (speedup). + return [(self.DIFF_DELETE, text1)] + + if len(text1) > len(text2): + (longtext, shorttext) = (text1, text2) + else: + (shorttext, longtext) = (text1, text2) + i = longtext.find(shorttext) + if i != -1: + # Shorter text is inside the longer text (speedup). + diffs = [ + (self.DIFF_INSERT, longtext[:i]), + (self.DIFF_EQUAL, shorttext), + (self.DIFF_INSERT, longtext[i + len(shorttext) :]), + ] + # Swap insertions for deletions if diff is reversed. + if len(text1) > len(text2): + diffs[0] = (self.DIFF_DELETE, diffs[0][1]) + diffs[2] = (self.DIFF_DELETE, diffs[2][1]) + return diffs - if blankLine1 or blankLine2: - # Five points for blank lines. - return 5 - elif lineBreak1 or lineBreak2: - # Four points for line breaks. - return 4 - elif nonAlphaNumeric1 and not whitespace1 and whitespace2: - # Three points for end of sentences. - return 3 - elif whitespace1 or whitespace2: - # Two points for whitespace. - return 2 - elif nonAlphaNumeric1 or nonAlphaNumeric2: - # One point for non-alphanumeric. - return 1 - return 0 + if len(shorttext) == 1: + # Single character string. + # After the previous speedup, the character can't be an equality. + return [(self.DIFF_DELETE, text1), (self.DIFF_INSERT, text2)] + + # Check to see if the problem can be split in two. + hm = self.diff_halfMatch(text1, text2) + if hm: + # A half-match was found, sort out the return data. + (text1_a, text1_b, text2_a, text2_b, mid_common) = hm + # Send both pairs off for separate processing. + diffs_a = self.diff_main(text1_a, text2_a, checklines, deadline) + diffs_b = self.diff_main(text1_b, text2_b, checklines, deadline) + # Merge the results. + return diffs_a + [(self.DIFF_EQUAL, mid_common)] + diffs_b + + if checklines and len(text1) > 100 and len(text2) > 100: + return self.diff_lineMode(text1, text2, deadline) + + return self.diff_bisect(text1, text2, deadline) + + def diff_lineMode(self, text1, text2, deadline): + """Do a quick line-level diff on both strings, then rediff the parts for + greater accuracy. + This speedup can produce non-minimal diffs. + + Args: + text1: Old string to be diffed. + text2: New string to be diffed. + deadline: Time when the diff should be complete by. + + Returns: + Array of changes. + """ - pointer = 1 - # Intentionally ignore the first and last element (don't need checking). - while pointer < len(diffs) - 1: - if (diffs[pointer - 1][0] == self.DIFF_EQUAL and - diffs[pointer + 1][0] == self.DIFF_EQUAL): - # This is a single edit surrounded by equalities. - equality1 = diffs[pointer - 1][1] - edit = diffs[pointer][1] - equality2 = diffs[pointer + 1][1] + # Scan the text on a line-by-line basis first. + (text1, text2, linearray) = self.diff_linesToChars(text1, text2) + + diffs = self.diff_main(text1, text2, False, deadline) + + # Convert the diff back to original text. + self.diff_charsToLines(diffs, linearray) + # Eliminate freak matches (e.g. blank lines) + self.diff_cleanupSemantic(diffs) + + # Rediff any replacement blocks, this time character-by-character. + # Add a dummy entry at the end. + diffs.append((self.DIFF_EQUAL, "")) + pointer = 0 + count_delete = 0 + count_insert = 0 + text_delete = "" + text_insert = "" + while pointer < len(diffs): + if diffs[pointer][0] == self.DIFF_INSERT: + count_insert += 1 + text_insert += diffs[pointer][1] + elif diffs[pointer][0] == self.DIFF_DELETE: + count_delete += 1 + text_delete += diffs[pointer][1] + elif diffs[pointer][0] == self.DIFF_EQUAL: + # Upon reaching an equality, check for prior redundancies. + if count_delete >= 1 and count_insert >= 1: + # Delete the offending records and add the merged ones. + a = self.diff_main(text_delete, text_insert, False, deadline) + diffs[pointer - count_delete - count_insert : pointer] = a + pointer = pointer - count_delete - count_insert + len(a) + count_insert = 0 + count_delete = 0 + text_delete = "" + text_insert = "" - # First, shift the edit as far left as possible. - commonOffset = self.diff_commonSuffix(equality1, edit) - if commonOffset: - commonString = edit[-commonOffset:] - equality1 = equality1[:-commonOffset] - edit = commonString + edit[:-commonOffset] - equality2 = commonString + equality2 + pointer += 1 + + diffs.pop() # Remove the dummy entry at the end. + + return diffs + + def diff_bisect(self, text1, text2, deadline): + """Find the 'middle snake' of a diff, split the problem in two + and return the recursively constructed diff. + See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations. + + Args: + text1: Old string to be diffed. + text2: New string to be diffed. + deadline: Time at which to bail if not yet complete. + + Returns: + Array of diff tuples. + """ - # Second, step character by character right, looking for the best fit. - bestEquality1 = equality1 - bestEdit = edit - bestEquality2 = equality2 - bestScore = (diff_cleanupSemanticScore(equality1, edit) + - diff_cleanupSemanticScore(edit, equality2)) - while edit and equality2 and edit[0] == equality2[0]: - equality1 += edit[0] - edit = edit[1:] + equality2[0] - equality2 = equality2[1:] - score = (diff_cleanupSemanticScore(equality1, edit) + - diff_cleanupSemanticScore(edit, equality2)) - # The >= encourages trailing rather than leading whitespace on edits. - if score >= bestScore: - bestScore = score - bestEquality1 = equality1 - bestEdit = edit - bestEquality2 = equality2 + # Cache the text lengths to prevent multiple calls. + text1_length = len(text1) + text2_length = len(text2) + max_d = (text1_length + text2_length + 1) // 2 + v_offset = max_d + v_length = 2 * max_d + v1 = [-1] * v_length + v1[v_offset + 1] = 0 + v2 = v1[:] + delta = text1_length - text2_length + # If the total number of characters is odd, then the front path will + # collide with the reverse path. + front = delta % 2 != 0 + # Offsets for start and end of k loop. + # Prevents mapping of space beyond the grid. + k1start = 0 + k1end = 0 + k2start = 0 + k2end = 0 + for d in range(max_d): + # Bail out if deadline is reached. + if time.time() > deadline: + break + + # Walk the front path one step. + for k1 in range(-d + k1start, d + 1 - k1end, 2): + k1_offset = v_offset + k1 + if k1 == -d or (k1 != d and v1[k1_offset - 1] < v1[k1_offset + 1]): + x1 = v1[k1_offset + 1] + else: + x1 = v1[k1_offset - 1] + 1 + y1 = x1 - k1 + while ( + x1 < text1_length and y1 < text2_length and text1[x1] == text2[y1] + ): + x1 += 1 + y1 += 1 + v1[k1_offset] = x1 + if x1 > text1_length: + # Ran off the right of the graph. + k1end += 2 + elif y1 > text2_length: + # Ran off the bottom of the graph. + k1start += 2 + elif front: + k2_offset = v_offset + delta - k1 + if k2_offset >= 0 and k2_offset < v_length and v2[k2_offset] != -1: + # Mirror x2 onto top-left coordinate system. + x2 = text1_length - v2[k2_offset] + if x1 >= x2: + # Overlap detected. + return self.diff_bisectSplit(text1, text2, x1, y1, deadline) - if diffs[pointer - 1][1] != bestEquality1: - # We have an improvement, save it back to the diff. - if bestEquality1: - diffs[pointer - 1] = (diffs[pointer - 1][0], bestEquality1) - else: - del diffs[pointer - 1] - pointer -= 1 - diffs[pointer] = (diffs[pointer][0], bestEdit) - if bestEquality2: - diffs[pointer + 1] = (diffs[pointer + 1][0], bestEquality2) - else: - del diffs[pointer + 1] - pointer -= 1 - pointer += 1 + # Walk the reverse path one step. + for k2 in range(-d + k2start, d + 1 - k2end, 2): + k2_offset = v_offset + k2 + if k2 == -d or (k2 != d and v2[k2_offset - 1] < v2[k2_offset + 1]): + x2 = v2[k2_offset + 1] + else: + x2 = v2[k2_offset - 1] + 1 + y2 = x2 - k2 + while ( + x2 < text1_length + and y2 < text2_length + and text1[-x2 - 1] == text2[-y2 - 1] + ): + x2 += 1 + y2 += 1 + v2[k2_offset] = x2 + if x2 > text1_length: + # Ran off the left of the graph. + k2end += 2 + elif y2 > text2_length: + # Ran off the top of the graph. + k2start += 2 + elif not front: + k1_offset = v_offset + delta - k2 + if k1_offset >= 0 and k1_offset < v_length and v1[k1_offset] != -1: + x1 = v1[k1_offset] + y1 = v_offset + x1 - k1_offset + # Mirror x2 onto top-left coordinate system. + x2 = text1_length - x2 + if x1 >= x2: + # Overlap detected. + return self.diff_bisectSplit(text1, text2, x1, y1, deadline) + + # Diff took too long and hit the deadline or + # number of diffs equals number of characters, no commonality at all. + return [(self.DIFF_DELETE, text1), (self.DIFF_INSERT, text2)] + + def diff_bisectSplit(self, text1, text2, x, y, deadline): + """Given the location of the 'middle snake', split the diff in two parts + and recurse. + + Args: + text1: Old string to be diffed. + text2: New string to be diffed. + x: Index of split point in text1. + y: Index of split point in text2. + deadline: Time at which to bail if not yet complete. + + Returns: + Array of diff tuples. + """ + text1a = text1[:x] + text2a = text2[:y] + text1b = text1[x:] + text2b = text2[y:] + + # Compute both diffs serially. + diffs = self.diff_main(text1a, text2a, False, deadline) + diffsb = self.diff_main(text1b, text2b, False, deadline) - # Define some regex patterns for matching boundaries. - BLANKLINEEND = re.compile(r"\n\r?\n$"); - BLANKLINESTART = re.compile(r"^\r?\n\r?\n"); + return diffs + diffsb + + def diff_linesToChars(self, text1, text2): + """Split two texts into an array of strings. Reduce the texts to a string + of hashes where each Unicode character represents one line. + + Args: + text1: First string. + text2: Second string. + + Returns: + Three element tuple, containing the encoded text1, the encoded text2 and + the array of unique strings. The zeroth element of the array of unique + strings is intentionally blank. + """ + lineArray = [] # e.g. lineArray[4] == "Hello\n" + lineHash = {} # e.g. lineHash["Hello\n"] == 4 + + # "\x00" is a valid character, but various debuggers don't like it. + # So we'll insert a junk entry to avoid generating a null character. + lineArray.append("") + + def diff_linesToCharsMunge(text): + """Split a text into an array of strings. Reduce the texts to a string + of hashes where each Unicode character represents one line. + Modifies linearray and linehash through being a closure. + + Args: + text: String to encode. + + Returns: + Encoded string. + """ + chars = [] + # Walk the text, pulling out a substring for each line. + # text.split('\n') would would temporarily double our memory footprint. + # Modifying text would create many large strings to garbage collect. + lineStart = 0 + lineEnd = -1 + while lineEnd < len(text) - 1: + lineEnd = text.find("\n", lineStart) + if lineEnd == -1: + lineEnd = len(text) - 1 + line = text[lineStart : lineEnd + 1] + lineStart = lineEnd + 1 + + if line in lineHash: + chars.append(chr(lineHash[line])) + else: + lineArray.append(line) + lineHash[line] = len(lineArray) - 1 + chars.append(chr(len(lineArray) - 1)) + return "".join(chars) + + chars1 = diff_linesToCharsMunge(text1) + chars2 = diff_linesToCharsMunge(text2) + return (chars1, chars2, lineArray) + + def diff_charsToLines(self, diffs, lineArray): + """Rehydrate the text in a diff from a string of line hashes to real lines + of text. - def diff_cleanupEfficiency(self, diffs): - """Reduce the number of edits by eliminating operationally trivial - equalities. + Args: + diffs: Array of diff tuples. + lineArray: Array of unique strings. + """ + for x in range(len(diffs)): + text = [] + for char in diffs[x][1]: + text.append(lineArray[ord(char)]) + diffs[x] = (diffs[x][0], "".join(text)) + + def diff_commonPrefix(self, text1, text2): + """Determine the common prefix of two strings. + + Args: + text1: First string. + text2: Second string. + + Returns: + The number of characters common to the start of each string. + """ + # Quick check for common null cases. + if not text1 or not text2 or text1[0] != text2[0]: + return 0 + # Binary search. + # Performance analysis: http://neil.fraser.name/news/2007/10/09/ + pointermin = 0 + pointermax = min(len(text1), len(text2)) + pointermid = pointermax + pointerstart = 0 + while pointermin < pointermid: + if text1[pointerstart:pointermid] == text2[pointerstart:pointermid]: + pointermin = pointermid + pointerstart = pointermin + else: + pointermax = pointermid + pointermid = (pointermax - pointermin) // 2 + pointermin + return pointermid + + def diff_commonSuffix(self, text1, text2): + """Determine the common suffix of two strings. + + Args: + text1: First string. + text2: Second string. - Args: - diffs: Array of diff tuples. - """ - changes = False - equalities = [] # Stack of indices where equalities are found. - lastequality = None # Always equal to diffs[equalities[-1]][1] - pointer = 0 # Index of current position. - pre_ins = False # Is there an insertion operation before the last equality. - pre_del = False # Is there a deletion operation before the last equality. - post_ins = False # Is there an insertion operation after the last equality. - post_del = False # Is there a deletion operation after the last equality. - while pointer < len(diffs): - if diffs[pointer][0] == self.DIFF_EQUAL: # Equality found. - if (len(diffs[pointer][1]) < self.Diff_EditCost and - (post_ins or post_del)): - # Candidate found. - equalities.append(pointer) - pre_ins = post_ins - pre_del = post_del - lastequality = diffs[pointer][1] + Returns: + The number of characters common to the end of each string. + """ + # Quick check for common null cases. + if not text1 or not text2 or text1[-1] != text2[-1]: + return 0 + # Binary search. + # Performance analysis: http://neil.fraser.name/news/2007/10/09/ + pointermin = 0 + pointermax = min(len(text1), len(text2)) + pointermid = pointermax + pointerend = 0 + while pointermin < pointermid: + if ( + text1[-pointermid : len(text1) - pointerend] + == text2[-pointermid : len(text2) - pointerend] + ): + pointermin = pointermid + pointerend = pointermin + else: + pointermax = pointermid + pointermid = (pointermax - pointermin) // 2 + pointermin + return pointermid + + def diff_commonOverlap(self, text1, text2): + """Determine if the suffix of one string is the prefix of another. + + Args: + text1 First string. + text2 Second string. + + Returns: + The number of characters common to the end of the first + string and the start of the second string. + """ + # Cache the text lengths to prevent multiple calls. + text1_length = len(text1) + text2_length = len(text2) + # Eliminate the null case. + if text1_length == 0 or text2_length == 0: + return 0 + # Truncate the longer string. + if text1_length > text2_length: + text1 = text1[-text2_length:] + elif text1_length < text2_length: + text2 = text2[:text1_length] + text_length = min(text1_length, text2_length) + # Quick check for the worst case. + if text1 == text2: + return text_length + + # Start by looking for a single character match + # and increase length until no match is found. + # Performance analysis: http://neil.fraser.name/news/2010/11/04/ + best = 0 + length = 1 + while True: + pattern = text1[-length:] + found = text2.find(pattern) + if found == -1: + return best + length += found + if found == 0 or text1[-length:] == text2[:length]: + best = length + length += 1 + + def diff_halfMatch(self, text1, text2): + """Do the two texts share a substring which is at least half the length of + the longer text? + This speedup can produce non-minimal diffs. + + Args: + text1: First string. + text2: Second string. + + Returns: + Five element Array, containing the prefix of text1, the suffix of text1, + the prefix of text2, the suffix of text2 and the common middle. Or None + if there was no match. + """ + if self.Diff_Timeout <= 0: + # Don't risk returning a non-optimal diff if we have unlimited time. + return None + if len(text1) > len(text2): + (longtext, shorttext) = (text1, text2) else: - # Not a candidate, and can never become one. - equalities = [] - lastequality = None + (shorttext, longtext) = (text1, text2) + if len(longtext) < 4 or len(shorttext) * 2 < len(longtext): + return None # Pointless. - post_ins = post_del = False - else: # An insertion or deletion. - if diffs[pointer][0] == self.DIFF_DELETE: - post_del = True - else: - post_ins = True + def diff_halfMatchI(longtext, shorttext, i): + """Does a substring of shorttext exist within longtext such that the + substring is at least half the length of longtext? + Closure, but does not reference any external variables. - # Five types to be split: - # ABXYCD - # AXCD - # ABXC - # AXCD - # ABXC + Args: + longtext: Longer string. + shorttext: Shorter string. + i: Start index of quarter length substring within longtext. - if lastequality and ((pre_ins and pre_del and post_ins and post_del) or - ((len(lastequality) < self.Diff_EditCost / 2) and - (pre_ins + pre_del + post_ins + post_del) == 3)): - # Duplicate record. - diffs.insert(equalities[-1], (self.DIFF_DELETE, lastequality)) - # Change second copy to insert. - diffs[equalities[-1] + 1] = (self.DIFF_INSERT, - diffs[equalities[-1] + 1][1]) - equalities.pop() # Throw away the equality we just deleted. - lastequality = None - if pre_ins and pre_del: - # No changes made which could affect previous entry, keep going. - post_ins = post_del = True - equalities = [] - else: - if len(equalities): - equalities.pop() # Throw away the previous equality. - if len(equalities): - pointer = equalities[-1] - else: - pointer = -1 - post_ins = post_del = False - changes = True - pointer += 1 - - if changes: - self.diff_cleanupMerge(diffs) - - def diff_cleanupMerge(self, diffs): - """Reorder and merge like edit sections. Merge equalities. - Any edit section can move as long as it doesn't cross an equality. + Returns: + Five element Array, containing the prefix of longtext, the suffix of + longtext, the prefix of shorttext, the suffix of shorttext and the + common middle. Or None if there was no match. + """ + seed = longtext[i : i + len(longtext) // 4] + best_common = "" + j = shorttext.find(seed) + while j != -1: + prefixLength = self.diff_commonPrefix(longtext[i:], shorttext[j:]) + suffixLength = self.diff_commonSuffix(longtext[:i], shorttext[:j]) + if len(best_common) < suffixLength + prefixLength: + best_common = ( + shorttext[j - suffixLength : j] + + shorttext[j : j + prefixLength] + ) + best_longtext_a = longtext[: i - suffixLength] + best_longtext_b = longtext[i + prefixLength :] + best_shorttext_a = shorttext[: j - suffixLength] + best_shorttext_b = shorttext[j + prefixLength :] + j = shorttext.find(seed, j + 1) - Args: - diffs: Array of diff tuples. - """ - diffs.append((self.DIFF_EQUAL, '')) # Add a dummy entry at the end. - pointer = 0 - count_delete = 0 - count_insert = 0 - text_delete = '' - text_insert = '' - while pointer < len(diffs): - if diffs[pointer][0] == self.DIFF_INSERT: - count_insert += 1 - text_insert += diffs[pointer][1] - pointer += 1 - elif diffs[pointer][0] == self.DIFF_DELETE: - count_delete += 1 - text_delete += diffs[pointer][1] - pointer += 1 - elif diffs[pointer][0] == self.DIFF_EQUAL: - # Upon reaching an equality, check for prior redundancies. - if count_delete + count_insert > 1: - if count_delete != 0 and count_insert != 0: - # Factor out any common prefixies. - commonlength = self.diff_commonPrefix(text_insert, text_delete) - if commonlength != 0: - x = pointer - count_delete - count_insert - 1 - if x >= 0 and diffs[x][0] == self.DIFF_EQUAL: - diffs[x] = (diffs[x][0], diffs[x][1] + - text_insert[:commonlength]) - else: - diffs.insert(0, (self.DIFF_EQUAL, text_insert[:commonlength])) + if len(best_common) * 2 >= len(longtext): + return ( + best_longtext_a, + best_longtext_b, + best_shorttext_a, + best_shorttext_b, + best_common, + ) + else: + return None + + # First check if the second quarter is the seed for a half-match. + hm1 = diff_halfMatchI(longtext, shorttext, (len(longtext) + 3) // 4) + # Check again based on the third quarter. + hm2 = diff_halfMatchI(longtext, shorttext, (len(longtext) + 1) // 2) + if not hm1 and not hm2: + return None + elif not hm2: + hm = hm1 + elif not hm1: + hm = hm2 + else: + # Both matched. Select the longest. + if len(hm1[4]) > len(hm2[4]): + hm = hm1 + else: + hm = hm2 + + # A half-match was found, sort out the return data. + if len(text1) > len(text2): + (text1_a, text1_b, text2_a, text2_b, mid_common) = hm + else: + (text2_a, text2_b, text1_a, text1_b, mid_common) = hm + return (text1_a, text1_b, text2_a, text2_b, mid_common) + + def diff_cleanupSemantic(self, diffs): + """Reduce the number of edits by eliminating semantically trivial + equalities. + + Args: + diffs: Array of diff tuples. + """ + changes = False + equalities = [] # Stack of indices where equalities are found. + lastequality = None # Always equal to diffs[equalities[-1]][1] + pointer = 0 # Index of current position. + # Number of chars that changed prior to the equality. + length_insertions1, length_deletions1 = 0, 0 + # Number of chars that changed after the equality. + length_insertions2, length_deletions2 = 0, 0 + while pointer < len(diffs): + if diffs[pointer][0] == self.DIFF_EQUAL: # Equality found. + equalities.append(pointer) + length_insertions1, length_insertions2 = length_insertions2, 0 + length_deletions1, length_deletions2 = length_deletions2, 0 + lastequality = diffs[pointer][1] + else: # An insertion or deletion. + if diffs[pointer][0] == self.DIFF_INSERT: + length_insertions2 += len(diffs[pointer][1]) + else: + length_deletions2 += len(diffs[pointer][1]) + # Eliminate an equality that is smaller or equal to the edits on both + # sides of it. + if ( + lastequality + and ( + len(lastequality) <= max(length_insertions1, length_deletions1) + ) + and ( + len(lastequality) <= max(length_insertions2, length_deletions2) + ) + ): + # Duplicate record. + diffs.insert(equalities[-1], (self.DIFF_DELETE, lastequality)) + # Change second copy to insert. + diffs[equalities[-1] + 1] = ( + self.DIFF_INSERT, + diffs[equalities[-1] + 1][1], + ) + # Throw away the equality we just deleted. + equalities.pop() + # Throw away the previous equality (it needs to be reevaluated). + if len(equalities): + equalities.pop() + if len(equalities): + pointer = equalities[-1] + else: + pointer = -1 + # Reset the counters. + length_insertions1, length_deletions1 = 0, 0 + length_insertions2, length_deletions2 = 0, 0 + lastequality = None + changes = True + pointer += 1 + + # Normalize the diff. + if changes: + self.diff_cleanupMerge(diffs) + self.diff_cleanupSemanticLossless(diffs) + + # Find any overlaps between deletions and insertions. + # e.g: abcxxxxxxdef + # -> abcxxxdef + # e.g: xxxabcdefxxx + # -> defxxxabc + # Only extract an overlap if it is as big as the edit ahead or behind it. + pointer = 1 + while pointer < len(diffs): + if ( + diffs[pointer - 1][0] == self.DIFF_DELETE + and diffs[pointer][0] == self.DIFF_INSERT + ): + deletion = diffs[pointer - 1][1] + insertion = diffs[pointer][1] + overlap_length1 = self.diff_commonOverlap(deletion, insertion) + overlap_length2 = self.diff_commonOverlap(insertion, deletion) + if overlap_length1 >= overlap_length2: + if ( + overlap_length1 >= len(deletion) / 2.0 + or overlap_length1 >= len(insertion) / 2.0 + ): + # Overlap found. Insert an equality and trim the surrounding edits. + diffs.insert( + pointer, (self.DIFF_EQUAL, insertion[:overlap_length1]) + ) + diffs[pointer - 1] = ( + self.DIFF_DELETE, + deletion[: len(deletion) - overlap_length1], + ) + diffs[pointer + 1] = ( + self.DIFF_INSERT, + insertion[overlap_length1:], + ) + pointer += 1 + else: + if ( + overlap_length2 >= len(deletion) / 2.0 + or overlap_length2 >= len(insertion) / 2.0 + ): + # Reverse overlap found. + # Insert an equality and swap and trim the surrounding edits. + diffs.insert( + pointer, (self.DIFF_EQUAL, deletion[:overlap_length2]) + ) + diffs[pointer - 1] = ( + self.DIFF_INSERT, + insertion[: len(insertion) - overlap_length2], + ) + diffs[pointer + 1] = ( + self.DIFF_DELETE, + deletion[overlap_length2:], + ) + pointer += 1 pointer += 1 - text_insert = text_insert[commonlength:] - text_delete = text_delete[commonlength:] - # Factor out any common suffixies. - commonlength = self.diff_commonSuffix(text_insert, text_delete) - if commonlength != 0: - diffs[pointer] = (diffs[pointer][0], text_insert[-commonlength:] + - diffs[pointer][1]) - text_insert = text_insert[:-commonlength] - text_delete = text_delete[:-commonlength] - # Delete the offending records and add the merged ones. - if count_delete == 0: - diffs[pointer - count_insert : pointer] = [ - (self.DIFF_INSERT, text_insert)] - elif count_insert == 0: - diffs[pointer - count_delete : pointer] = [ - (self.DIFF_DELETE, text_delete)] - else: - diffs[pointer - count_delete - count_insert : pointer] = [ - (self.DIFF_DELETE, text_delete), - (self.DIFF_INSERT, text_insert)] - pointer = pointer - count_delete - count_insert + 1 - if count_delete != 0: pointer += 1 - if count_insert != 0: - pointer += 1 - elif pointer != 0 and diffs[pointer - 1][0] == self.DIFF_EQUAL: - # Merge this equality with the previous one. - diffs[pointer - 1] = (diffs[pointer - 1][0], - diffs[pointer - 1][1] + diffs[pointer][1]) - del diffs[pointer] - else: - pointer += 1 + + def diff_cleanupSemanticLossless(self, diffs): + """Look for single edits surrounded on both sides by equalities + which can be shifted sideways to align the edit to a word boundary. + e.g: The cat came. -> The cat came. + + Args: + diffs: Array of diff tuples. + """ + + def diff_cleanupSemanticScore(one, two): + """Given two strings, compute a score representing whether the + internal boundary falls on logical boundaries. + Scores range from 6 (best) to 0 (worst). + Closure, but does not reference any external variables. + + Args: + one: First string. + two: Second string. + + Returns: + The score. + """ + if not one or not two: + # Edges are the best. + return 6 + + # Each port of this function behaves slightly differently due to + # subtle differences in each language's definition of things like + # 'whitespace'. Since this function's purpose is largely cosmetic, + # the choice has been made to use each language's native features + # rather than force total conformity. + char1 = one[-1] + char2 = two[0] + nonAlphaNumeric1 = not char1.isalnum() + nonAlphaNumeric2 = not char2.isalnum() + whitespace1 = nonAlphaNumeric1 and char1.isspace() + whitespace2 = nonAlphaNumeric2 and char2.isspace() + lineBreak1 = whitespace1 and (char1 == "\r" or char1 == "\n") + lineBreak2 = whitespace2 and (char2 == "\r" or char2 == "\n") + blankLine1 = lineBreak1 and self.BLANKLINEEND.search(one) + blankLine2 = lineBreak2 and self.BLANKLINESTART.match(two) + + if blankLine1 or blankLine2: + # Five points for blank lines. + return 5 + elif lineBreak1 or lineBreak2: + # Four points for line breaks. + return 4 + elif nonAlphaNumeric1 and not whitespace1 and whitespace2: + # Three points for end of sentences. + return 3 + elif whitespace1 or whitespace2: + # Two points for whitespace. + return 2 + elif nonAlphaNumeric1 or nonAlphaNumeric2: + # One point for non-alphanumeric. + return 1 + return 0 - count_insert = 0 - count_delete = 0 - text_delete = '' - text_insert = '' + pointer = 1 + # Intentionally ignore the first and last element (don't need checking). + while pointer < len(diffs) - 1: + if ( + diffs[pointer - 1][0] == self.DIFF_EQUAL + and diffs[pointer + 1][0] == self.DIFF_EQUAL + ): + # This is a single edit surrounded by equalities. + equality1 = diffs[pointer - 1][1] + edit = diffs[pointer][1] + equality2 = diffs[pointer + 1][1] - if diffs[-1][1] == '': - diffs.pop() # Remove the dummy entry at the end. + # First, shift the edit as far left as possible. + commonOffset = self.diff_commonSuffix(equality1, edit) + if commonOffset: + commonString = edit[-commonOffset:] + equality1 = equality1[:-commonOffset] + edit = commonString + edit[:-commonOffset] + equality2 = commonString + equality2 - # Second pass: look for single edits surrounded on both sides by equalities - # which can be shifted sideways to eliminate an equality. - # e.g: ABAC -> ABAC - changes = False - pointer = 1 - # Intentionally ignore the first and last element (don't need checking). - while pointer < len(diffs) - 1: - if (diffs[pointer - 1][0] == self.DIFF_EQUAL and - diffs[pointer + 1][0] == self.DIFF_EQUAL): - # This is a single edit surrounded by equalities. - if diffs[pointer][1].endswith(diffs[pointer - 1][1]): - # Shift the edit over the previous equality. - diffs[pointer] = (diffs[pointer][0], - diffs[pointer - 1][1] + - diffs[pointer][1][:-len(diffs[pointer - 1][1])]) - diffs[pointer + 1] = (diffs[pointer + 1][0], - diffs[pointer - 1][1] + diffs[pointer + 1][1]) - del diffs[pointer - 1] - changes = True - elif diffs[pointer][1].startswith(diffs[pointer + 1][1]): - # Shift the edit over the next equality. - diffs[pointer - 1] = (diffs[pointer - 1][0], - diffs[pointer - 1][1] + diffs[pointer + 1][1]) - diffs[pointer] = (diffs[pointer][0], - diffs[pointer][1][len(diffs[pointer + 1][1]):] + - diffs[pointer + 1][1]) - del diffs[pointer + 1] - changes = True - pointer += 1 + # Second, step character by character right, looking for the best fit. + bestEquality1 = equality1 + bestEdit = edit + bestEquality2 = equality2 + bestScore = diff_cleanupSemanticScore( + equality1, edit + ) + diff_cleanupSemanticScore(edit, equality2) + while edit and equality2 and edit[0] == equality2[0]: + equality1 += edit[0] + edit = edit[1:] + equality2[0] + equality2 = equality2[1:] + score = diff_cleanupSemanticScore( + equality1, edit + ) + diff_cleanupSemanticScore(edit, equality2) + # The >= encourages trailing rather than leading whitespace on edits. + if score >= bestScore: + bestScore = score + bestEquality1 = equality1 + bestEdit = edit + bestEquality2 = equality2 + + if diffs[pointer - 1][1] != bestEquality1: + # We have an improvement, save it back to the diff. + if bestEquality1: + diffs[pointer - 1] = (diffs[pointer - 1][0], bestEquality1) + else: + del diffs[pointer - 1] + pointer -= 1 + diffs[pointer] = (diffs[pointer][0], bestEdit) + if bestEquality2: + diffs[pointer + 1] = (diffs[pointer + 1][0], bestEquality2) + else: + del diffs[pointer + 1] + pointer -= 1 + pointer += 1 + + # Define some regex patterns for matching boundaries. + BLANKLINEEND = re.compile(r"\n\r?\n$") + BLANKLINESTART = re.compile(r"^\r?\n\r?\n") + + def diff_cleanupEfficiency(self, diffs): + """Reduce the number of edits by eliminating operationally trivial + equalities. - # If shifts were made, the diff needs reordering and another shift sweep. - if changes: - self.diff_cleanupMerge(diffs) + Args: + diffs: Array of diff tuples. + """ + changes = False + equalities = [] # Stack of indices where equalities are found. + lastequality = None # Always equal to diffs[equalities[-1]][1] + pointer = 0 # Index of current position. + pre_ins = False # Is there an insertion operation before the last equality. + pre_del = False # Is there a deletion operation before the last equality. + post_ins = False # Is there an insertion operation after the last equality. + post_del = False # Is there a deletion operation after the last equality. + while pointer < len(diffs): + if diffs[pointer][0] == self.DIFF_EQUAL: # Equality found. + if len(diffs[pointer][1]) < self.Diff_EditCost and ( + post_ins or post_del + ): + # Candidate found. + equalities.append(pointer) + pre_ins = post_ins + pre_del = post_del + lastequality = diffs[pointer][1] + else: + # Not a candidate, and can never become one. + equalities = [] + lastequality = None - def diff_xIndex(self, diffs, loc): - """loc is a location in text1, compute and return the equivalent location - in text2. e.g. "The cat" vs "The big cat", 1->1, 5->8 - - Args: - diffs: Array of diff tuples. - loc: Location within text1. + post_ins = post_del = False + else: # An insertion or deletion. + if diffs[pointer][0] == self.DIFF_DELETE: + post_del = True + else: + post_ins = True - Returns: - Location within text2. - """ - chars1 = 0 - chars2 = 0 - last_chars1 = 0 - last_chars2 = 0 - for x in range(len(diffs)): - (op, text) = diffs[x] - if op != self.DIFF_INSERT: # Equality or deletion. - chars1 += len(text) - if op != self.DIFF_DELETE: # Equality or insertion. - chars2 += len(text) - if chars1 > loc: # Overshot the location. - break - last_chars1 = chars1 - last_chars2 = chars2 + # Five types to be split: + # ABXYCD + # AXCD + # ABXC + # AXCD + # ABXC - if len(diffs) != x and diffs[x][0] == self.DIFF_DELETE: - # The location was deleted. - return last_chars2 - # Add the remaining len(character). - return last_chars2 + (loc - last_chars1) + if lastequality and ( + (pre_ins and pre_del and post_ins and post_del) + or ( + (len(lastequality) < self.Diff_EditCost / 2) + and (pre_ins + pre_del + post_ins + post_del) == 3 + ) + ): + # Duplicate record. + diffs.insert(equalities[-1], (self.DIFF_DELETE, lastequality)) + # Change second copy to insert. + diffs[equalities[-1] + 1] = ( + self.DIFF_INSERT, + diffs[equalities[-1] + 1][1], + ) + equalities.pop() # Throw away the equality we just deleted. + lastequality = None + if pre_ins and pre_del: + # No changes made which could affect previous entry, keep going. + post_ins = post_del = True + equalities = [] + else: + if len(equalities): + equalities.pop() # Throw away the previous equality. + if len(equalities): + pointer = equalities[-1] + else: + pointer = -1 + post_ins = post_del = False + changes = True + pointer += 1 - def diff_prettyHtml(self, diffs): - """Convert a diff array into a pretty HTML report. + if changes: + self.diff_cleanupMerge(diffs) - Args: - diffs: Array of diff tuples. + def diff_cleanupMerge(self, diffs): + """Reorder and merge like edit sections. Merge equalities. + Any edit section can move as long as it doesn't cross an equality. - Returns: - HTML representation. - """ - html = [] - for (op, data) in diffs: - text = (data.replace("&", "&").replace("<", "<") - .replace(">", ">").replace("\n", "¶
")) - if op == self.DIFF_INSERT: - html.append("%s" % text) - elif op == self.DIFF_DELETE: - html.append("%s" % text) - elif op == self.DIFF_EQUAL: - html.append("%s" % text) - return "".join(html) + Args: + diffs: Array of diff tuples. + """ + diffs.append((self.DIFF_EQUAL, "")) # Add a dummy entry at the end. + pointer = 0 + count_delete = 0 + count_insert = 0 + text_delete = "" + text_insert = "" + while pointer < len(diffs): + if diffs[pointer][0] == self.DIFF_INSERT: + count_insert += 1 + text_insert += diffs[pointer][1] + pointer += 1 + elif diffs[pointer][0] == self.DIFF_DELETE: + count_delete += 1 + text_delete += diffs[pointer][1] + pointer += 1 + elif diffs[pointer][0] == self.DIFF_EQUAL: + # Upon reaching an equality, check for prior redundancies. + if count_delete + count_insert > 1: + if count_delete != 0 and count_insert != 0: + # Factor out any common prefixies. + commonlength = self.diff_commonPrefix(text_insert, text_delete) + if commonlength != 0: + x = pointer - count_delete - count_insert - 1 + if x >= 0 and diffs[x][0] == self.DIFF_EQUAL: + diffs[x] = ( + diffs[x][0], + diffs[x][1] + text_insert[:commonlength], + ) + else: + diffs.insert( + 0, (self.DIFF_EQUAL, text_insert[:commonlength]) + ) + pointer += 1 + text_insert = text_insert[commonlength:] + text_delete = text_delete[commonlength:] + # Factor out any common suffixies. + commonlength = self.diff_commonSuffix(text_insert, text_delete) + if commonlength != 0: + diffs[pointer] = ( + diffs[pointer][0], + text_insert[-commonlength:] + diffs[pointer][1], + ) + text_insert = text_insert[:-commonlength] + text_delete = text_delete[:-commonlength] + # Delete the offending records and add the merged ones. + if count_delete == 0: + diffs[pointer - count_insert : pointer] = [ + (self.DIFF_INSERT, text_insert) + ] + elif count_insert == 0: + diffs[pointer - count_delete : pointer] = [ + (self.DIFF_DELETE, text_delete) + ] + else: + diffs[pointer - count_delete - count_insert : pointer] = [ + (self.DIFF_DELETE, text_delete), + (self.DIFF_INSERT, text_insert), + ] + pointer = pointer - count_delete - count_insert + 1 + if count_delete != 0: + pointer += 1 + if count_insert != 0: + pointer += 1 + elif pointer != 0 and diffs[pointer - 1][0] == self.DIFF_EQUAL: + # Merge this equality with the previous one. + diffs[pointer - 1] = ( + diffs[pointer - 1][0], + diffs[pointer - 1][1] + diffs[pointer][1], + ) + del diffs[pointer] + else: + pointer += 1 - def diff_text1(self, diffs): - """Compute and return the source text (all equalities and deletions). - - Args: - diffs: Array of diff tuples. + count_insert = 0 + count_delete = 0 + text_delete = "" + text_insert = "" - Returns: - Source text. - """ - text = [] - for (op, data) in diffs: - if op != self.DIFF_INSERT: - text.append(data) - return "".join(text) - - def diff_text2(self, diffs): - """Compute and return the destination text (all equalities and insertions). + if diffs[-1][1] == "": + diffs.pop() # Remove the dummy entry at the end. - Args: - diffs: Array of diff tuples. + # Second pass: look for single edits surrounded on both sides by equalities + # which can be shifted sideways to eliminate an equality. + # e.g: ABAC -> ABAC + changes = False + pointer = 1 + # Intentionally ignore the first and last element (don't need checking). + while pointer < len(diffs) - 1: + if ( + diffs[pointer - 1][0] == self.DIFF_EQUAL + and diffs[pointer + 1][0] == self.DIFF_EQUAL + ): + # This is a single edit surrounded by equalities. + if diffs[pointer][1].endswith(diffs[pointer - 1][1]): + # Shift the edit over the previous equality. + diffs[pointer] = ( + diffs[pointer][0], + diffs[pointer - 1][1] + + diffs[pointer][1][: -len(diffs[pointer - 1][1])], + ) + diffs[pointer + 1] = ( + diffs[pointer + 1][0], + diffs[pointer - 1][1] + diffs[pointer + 1][1], + ) + del diffs[pointer - 1] + changes = True + elif diffs[pointer][1].startswith(diffs[pointer + 1][1]): + # Shift the edit over the next equality. + diffs[pointer - 1] = ( + diffs[pointer - 1][0], + diffs[pointer - 1][1] + diffs[pointer + 1][1], + ) + diffs[pointer] = ( + diffs[pointer][0], + diffs[pointer][1][len(diffs[pointer + 1][1]) :] + + diffs[pointer + 1][1], + ) + del diffs[pointer + 1] + changes = True + pointer += 1 - Returns: - Destination text. - """ - text = [] - for (op, data) in diffs: - if op != self.DIFF_DELETE: - text.append(data) - return "".join(text) + # If shifts were made, the diff needs reordering and another shift sweep. + if changes: + self.diff_cleanupMerge(diffs) + + def diff_xIndex(self, diffs, loc): + """loc is a location in text1, compute and return the equivalent location + in text2. e.g. "The cat" vs "The big cat", 1->1, 5->8 + + Args: + diffs: Array of diff tuples. + loc: Location within text1. - def diff_levenshtein(self, diffs): - """Compute the Levenshtein distance; the number of inserted, deleted or - substituted characters. + Returns: + Location within text2. + """ + chars1 = 0 + chars2 = 0 + last_chars1 = 0 + last_chars2 = 0 + for x in range(len(diffs)): + (op, text) = diffs[x] + if op != self.DIFF_INSERT: # Equality or deletion. + chars1 += len(text) + if op != self.DIFF_DELETE: # Equality or insertion. + chars2 += len(text) + if chars1 > loc: # Overshot the location. + break + last_chars1 = chars1 + last_chars2 = chars2 - Args: - diffs: Array of diff tuples. + if len(diffs) != x and diffs[x][0] == self.DIFF_DELETE: + # The location was deleted. + return last_chars2 + # Add the remaining len(character). + return last_chars2 + (loc - last_chars1) + + def diff_prettyHtml(self, diffs): + """Convert a diff array into a pretty HTML report. + + Args: + diffs: Array of diff tuples. + + Returns: + HTML representation. + """ + html = [] + for op, data in diffs: + text = ( + data.replace("&", "&") + .replace("<", "<") + .replace(">", ">") + .replace("\n", "¶
") + ) + if op == self.DIFF_INSERT: + html.append('%s' % text) + elif op == self.DIFF_DELETE: + html.append('%s' % text) + elif op == self.DIFF_EQUAL: + html.append("%s" % text) + return "".join(html) + + def diff_text1(self, diffs): + """Compute and return the source text (all equalities and deletions). - Returns: - Number of changes. - """ - levenshtein = 0 - insertions = 0 - deletions = 0 - for (op, data) in diffs: - if op == self.DIFF_INSERT: - insertions += len(data) - elif op == self.DIFF_DELETE: - deletions += len(data) - elif op == self.DIFF_EQUAL: - # A deletion and an insertion is one substitution. - levenshtein += max(insertions, deletions) + Args: + diffs: Array of diff tuples. + + Returns: + Source text. + """ + text = [] + for op, data in diffs: + if op != self.DIFF_INSERT: + text.append(data) + return "".join(text) + + def diff_text2(self, diffs): + """Compute and return the destination text (all equalities and insertions). + + Args: + diffs: Array of diff tuples. + + Returns: + Destination text. + """ + text = [] + for op, data in diffs: + if op != self.DIFF_DELETE: + text.append(data) + return "".join(text) + + def diff_levenshtein(self, diffs): + """Compute the Levenshtein distance; the number of inserted, deleted or + substituted characters. + + Args: + diffs: Array of diff tuples. + + Returns: + Number of changes. + """ + levenshtein = 0 insertions = 0 deletions = 0 - levenshtein += max(insertions, deletions) - return levenshtein + for op, data in diffs: + if op == self.DIFF_INSERT: + insertions += len(data) + elif op == self.DIFF_DELETE: + deletions += len(data) + elif op == self.DIFF_EQUAL: + # A deletion and an insertion is one substitution. + levenshtein += max(insertions, deletions) + insertions = 0 + deletions = 0 + levenshtein += max(insertions, deletions) + return levenshtein - def diff_toDelta(self, diffs): - """Crush the diff into an encoded string which describes the operations - required to transform text1 into text2. - E.g. =3\t-2\t+ing -> Keep 3 chars, delete 2 chars, insert 'ing'. - Operations are tab-separated. Inserted text is escaped using %xx notation. + def diff_toDelta(self, diffs): + """Crush the diff into an encoded string which describes the operations + required to transform text1 into text2. + E.g. =3\t-2\t+ing -> Keep 3 chars, delete 2 chars, insert 'ing'. + Operations are tab-separated. Inserted text is escaped using %xx notation. - Args: - diffs: Array of diff tuples. + Args: + diffs: Array of diff tuples. - Returns: - Delta text. - """ - text = [] - for (op, data) in diffs: - if op == self.DIFF_INSERT: - # High ascii will raise UnicodeDecodeError. Use Unicode instead. - data = data.encode("utf-8") - text.append("+" + urllib.parse.quote(data, "!~*'();/?:@&=+$,# ")) - elif op == self.DIFF_DELETE: - text.append("-%d" % len(data)) - elif op == self.DIFF_EQUAL: - text.append("=%d" % len(data)) - return "\t".join(text) + Returns: + Delta text. + """ + text = [] + for op, data in diffs: + if op == self.DIFF_INSERT: + # High ascii will raise UnicodeDecodeError. Use Unicode instead. + data = data.encode("utf-8") + text.append("+" + urllib.parse.quote(data, "!~*'();/?:@&=+$,# ")) + elif op == self.DIFF_DELETE: + text.append("-%d" % len(data)) + elif op == self.DIFF_EQUAL: + text.append("=%d" % len(data)) + return "\t".join(text) - def diff_fromDelta(self, text1, delta): - """Given the original text1, and an encoded string which describes the - operations required to transform text1 into text2, compute the full diff. + def diff_fromDelta(self, text1, delta): + """Given the original text1, and an encoded string which describes the + operations required to transform text1 into text2, compute the full diff. - Args: - text1: Source string for the diff. - delta: Delta text. - - Returns: - Array of diff tuples. + Args: + text1: Source string for the diff. + delta: Delta text. - Raises: - ValueError: If invalid input. - """ - if type(delta) == unicode: - # Deltas should be composed of a subset of ascii chars, Unicode not - # required. If this encode raises UnicodeEncodeError, delta is invalid. - delta = delta.encode("ascii") - diffs = [] - pointer = 0 # Cursor in text1 - tokens = delta.split("\t") - for token in tokens: - if token == "": - # Blank tokens are ok (from a trailing \t). - continue - # Each token begins with a one character parameter which specifies the - # operation of this token (delete, insert, equality). - param = token[1:] - if token[0] == "+": - param = urllib.parse.unquote(param).decode("utf-8") - diffs.append((self.DIFF_INSERT, param)) - elif token[0] == "-" or token[0] == "=": - try: - n = int(param) - except ValueError: - raise ValueError("Invalid number in diff_fromDelta: " + param) - if n < 0: - raise ValueError("Negative number in diff_fromDelta: " + param) - text = text1[pointer : pointer + n] - pointer += n - if token[0] == "=": - diffs.append((self.DIFF_EQUAL, text)) - else: - diffs.append((self.DIFF_DELETE, text)) - else: - # Anything else is an error. - raise ValueError("Invalid diff operation in diff_fromDelta: " + - token[0]) - if pointer != len(text1): - raise ValueError( - "Delta length (%d) does not equal source text length (%d)." % - (pointer, len(text1))) - return diffs + Returns: + Array of diff tuples. - # MATCH FUNCTIONS + Raises: + ValueError: If invalid input. + """ + if type(delta) == str: + # Deltas should be composed of a subset of ascii chars, Unicode not + # required. If this encode raises UnicodeEncodeError, delta is invalid. + delta = delta.encode("ascii") + diffs = [] + pointer = 0 # Cursor in text1 + tokens = delta.split("\t") + for token in tokens: + if token == "": + # Blank tokens are ok (from a trailing \t). + continue + # Each token begins with a one character parameter which specifies the + # operation of this token (delete, insert, equality). + param = token[1:] + if token[0] == "+": + param = urllib.parse.unquote(param) + diffs.append((self.DIFF_INSERT, param)) + elif token[0] == "-" or token[0] == "=": + try: + n = int(param) + except ValueError: + raise ValueError("Invalid number in diff_fromDelta: " + param) + if n < 0: + raise ValueError("Negative number in diff_fromDelta: " + param) + text = text1[pointer : pointer + n] + pointer += n + if token[0] == "=": + diffs.append((self.DIFF_EQUAL, text)) + else: + diffs.append((self.DIFF_DELETE, text)) + else: + # Anything else is an error. + raise ValueError( + "Invalid diff operation in diff_fromDelta: " + token[0] + ) + if pointer != len(text1): + raise ValueError( + "Delta length (%d) does not equal source text length (%d)." + % (pointer, len(text1)) + ) + return diffs - def match_main(self, text, pattern, loc): - """Locate the best instance of 'pattern' in 'text' near 'loc'. + # MATCH FUNCTIONS - Args: - text: The text to search. - pattern: The pattern to search for. - loc: The location to search around. + def match_main(self, text, pattern, loc): + """Locate the best instance of 'pattern' in 'text' near 'loc'. - Returns: - Best match index or -1. - """ - # Check for null inputs. - if text is None or pattern is None: - raise ValueError("Null inputs. (match_main)") + Args: + text: The text to search. + pattern: The pattern to search for. + loc: The location to search around. + + Returns: + Best match index or -1. + """ + # Check for null inputs. + if text is None or pattern is None: + raise ValueError("Null inputs. (match_main)") - loc = max(0, min(loc, len(text))) - if text == pattern: - # Shortcut (potentially not guaranteed by the algorithm) - return 0 - elif not text: - # Nothing to match. - return -1 - elif text[loc:loc + len(pattern)] == pattern: - # Perfect match at the perfect spot! (Includes case of null pattern) - return loc - else: - # Do a fuzzy compare. - match = self.match_bitap(text, pattern, loc) - return match + loc = max(0, min(loc, len(text))) + if text == pattern: + # Shortcut (potentially not guaranteed by the algorithm) + return 0 + elif not text: + # Nothing to match. + return -1 + elif text[loc : loc + len(pattern)] == pattern: + # Perfect match at the perfect spot! (Includes case of null pattern) + return loc + else: + # Do a fuzzy compare. + match = self.match_bitap(text, pattern, loc) + return match - def match_bitap(self, text, pattern, loc): - """Locate the best instance of 'pattern' in 'text' near 'loc' using the - Bitap algorithm. + def match_bitap(self, text, pattern, loc): + """Locate the best instance of 'pattern' in 'text' near 'loc' using the + Bitap algorithm. - Args: - text: The text to search. - pattern: The pattern to search for. - loc: The location to search around. + Args: + text: The text to search. + pattern: The pattern to search for. + loc: The location to search around. - Returns: - Best match index or -1. - """ - # Python doesn't have a maxint limit, so ignore this check. - #if self.Match_MaxBits != 0 and len(pattern) > self.Match_MaxBits: - # raise ValueError("Pattern too long for this application.") + Returns: + Best match index or -1. + """ + # Python doesn't have a maxint limit, so ignore this check. + # if self.Match_MaxBits != 0 and len(pattern) > self.Match_MaxBits: + # raise ValueError("Pattern too long for this application.") - # Initialise the alphabet. - s = self.match_alphabet(pattern) + # Initialise the alphabet. + s = self.match_alphabet(pattern) - def match_bitapScore(e, x): - """Compute and return the score for a match with e errors and x location. - Accesses loc and pattern through being a closure. + def match_bitapScore(e, x): + """Compute and return the score for a match with e errors and x location. + Accesses loc and pattern through being a closure. - Args: - e: Number of errors in match. - x: Location of match. + Args: + e: Number of errors in match. + x: Location of match. - Returns: - Overall score for match (0.0 = good, 1.0 = bad). - """ - accuracy = float(e) / len(pattern) - proximity = abs(loc - x) - if not self.Match_Distance: - # Dodge divide by zero error. - return proximity and 1.0 or accuracy - return accuracy + (proximity / float(self.Match_Distance)) + Returns: + Overall score for match (0.0 = good, 1.0 = bad). + """ + accuracy = float(e) / len(pattern) + proximity = abs(loc - x) + if not self.Match_Distance: + # Dodge divide by zero error. + return proximity and 1.0 or accuracy + return accuracy + (proximity / float(self.Match_Distance)) - # Highest score beyond which we give up. - score_threshold = self.Match_Threshold - # Is there a nearby exact match? (speedup) - best_loc = text.find(pattern, loc) - if best_loc != -1: - score_threshold = min(match_bitapScore(0, best_loc), score_threshold) - # What about in the other direction? (speedup) - best_loc = text.rfind(pattern, loc + len(pattern)) - if best_loc != -1: - score_threshold = min(match_bitapScore(0, best_loc), score_threshold) + # Highest score beyond which we give up. + score_threshold = self.Match_Threshold + # Is there a nearby exact match? (speedup) + best_loc = text.find(pattern, loc) + if best_loc != -1: + score_threshold = min(match_bitapScore(0, best_loc), score_threshold) + # What about in the other direction? (speedup) + best_loc = text.rfind(pattern, loc + len(pattern)) + if best_loc != -1: + score_threshold = min(match_bitapScore(0, best_loc), score_threshold) - # Initialise the bit arrays. - matchmask = 1 << (len(pattern) - 1) - best_loc = -1 + # Initialise the bit arrays. + matchmask = 1 << (len(pattern) - 1) + best_loc = -1 - bin_max = len(pattern) + len(text) - # Empty initialization added to appease pychecker. - last_rd = None - for d in range(len(pattern)): - # Scan for the best match each iteration allows for one more error. - # Run a binary search to determine how far from 'loc' we can stray at - # this error level. - bin_min = 0 - bin_mid = bin_max - while bin_min < bin_mid: - if match_bitapScore(d, loc + bin_mid) <= score_threshold: - bin_min = bin_mid - else: - bin_max = bin_mid - bin_mid = (bin_max - bin_min) // 2 + bin_min + bin_max = len(pattern) + len(text) + # Empty initialization added to appease pychecker. + last_rd = None + for d in range(len(pattern)): + # Scan for the best match each iteration allows for one more error. + # Run a binary search to determine how far from 'loc' we can stray at + # this error level. + bin_min = 0 + bin_mid = bin_max + while bin_min < bin_mid: + if match_bitapScore(d, loc + bin_mid) <= score_threshold: + bin_min = bin_mid + else: + bin_max = bin_mid + bin_mid = (bin_max - bin_min) // 2 + bin_min - # Use the result from this iteration as the maximum for the next. - bin_max = bin_mid - start = max(1, loc - bin_mid + 1) - finish = min(loc + bin_mid, len(text)) + len(pattern) + # Use the result from this iteration as the maximum for the next. + bin_max = bin_mid + start = max(1, loc - bin_mid + 1) + finish = min(loc + bin_mid, len(text)) + len(pattern) - rd = [0] * (finish + 2) - rd[finish + 1] = (1 << d) - 1 - for j in range(finish, start - 1, -1): - if len(text) <= j - 1: - # Out of range. - charMatch = 0 - else: - charMatch = s.get(text[j - 1], 0) - if d == 0: # First pass: exact match. - rd[j] = ((rd[j + 1] << 1) | 1) & charMatch - else: # Subsequent passes: fuzzy match. - rd[j] = (((rd[j + 1] << 1) | 1) & charMatch) | ( - ((last_rd[j + 1] | last_rd[j]) << 1) | 1) | last_rd[j + 1] - if rd[j] & matchmask: - score = match_bitapScore(d, j - 1) - # This match will almost certainly be better than any existing match. - # But check anyway. - if score <= score_threshold: - # Told you so. - score_threshold = score - best_loc = j - 1 - if best_loc > loc: - # When passing loc, don't exceed our current distance from loc. - start = max(1, 2 * loc - best_loc) - else: - # Already passed loc, downhill from here on in. - break - # No hope for a (better) match at greater error levels. - if match_bitapScore(d + 1, loc) > score_threshold: - break - last_rd = rd - return best_loc + rd = [0] * (finish + 2) + rd[finish + 1] = (1 << d) - 1 + for j in range(finish, start - 1, -1): + if len(text) <= j - 1: + # Out of range. + charMatch = 0 + else: + charMatch = s.get(text[j - 1], 0) + if d == 0: # First pass: exact match. + rd[j] = ((rd[j + 1] << 1) | 1) & charMatch + else: # Subsequent passes: fuzzy match. + rd[j] = ( + (((rd[j + 1] << 1) | 1) & charMatch) + | (((last_rd[j + 1] | last_rd[j]) << 1) | 1) + | last_rd[j + 1] + ) + if rd[j] & matchmask: + score = match_bitapScore(d, j - 1) + # This match will almost certainly be better than any existing match. + # But check anyway. + if score <= score_threshold: + # Told you so. + score_threshold = score + best_loc = j - 1 + if best_loc > loc: + # When passing loc, don't exceed our current distance from loc. + start = max(1, 2 * loc - best_loc) + else: + # Already passed loc, downhill from here on in. + break + # No hope for a (better) match at greater error levels. + if match_bitapScore(d + 1, loc) > score_threshold: + break + last_rd = rd + return best_loc - def match_alphabet(self, pattern): - """Initialise the alphabet for the Bitap algorithm. + def match_alphabet(self, pattern): + """Initialise the alphabet for the Bitap algorithm. - Args: - pattern: The text to encode. + Args: + pattern: The text to encode. - Returns: - Hash of character locations. - """ - s = {} - for char in pattern: - s[char] = 0 - for i in range(len(pattern)): - s[pattern[i]] |= 1 << (len(pattern) - i - 1) - return s + Returns: + Hash of character locations. + """ + s = {} + for char in pattern: + s[char] = 0 + for i in range(len(pattern)): + s[pattern[i]] |= 1 << (len(pattern) - i - 1) + return s - # PATCH FUNCTIONS + # PATCH FUNCTIONS - def patch_addContext(self, patch, text): - """Increase the context until it is unique, - but don't let the pattern expand beyond Match_MaxBits. + def patch_addContext(self, patch, text): + """Increase the context until it is unique, + but don't let the pattern expand beyond Match_MaxBits. - Args: - patch: The patch to grow. - text: Source text. - """ - if len(text) == 0: - return - pattern = text[patch.start2 : patch.start2 + patch.length1] - padding = 0 + Args: + patch: The patch to grow. + text: Source text. + """ + if len(text) == 0: + return + pattern = text[patch.start2 : patch.start2 + patch.length1] + padding = 0 - # Look for the first and last matches of pattern in text. If two different - # matches are found, increase the pattern length. - while (text.find(pattern) != text.rfind(pattern) and (self.Match_MaxBits == - 0 or len(pattern) < self.Match_MaxBits - self.Patch_Margin - - self.Patch_Margin)): - padding += self.Patch_Margin - pattern = text[max(0, patch.start2 - padding) : - patch.start2 + patch.length1 + padding] - # Add one chunk for good luck. - padding += self.Patch_Margin + # Look for the first and last matches of pattern in text. If two different + # matches are found, increase the pattern length. + while text.find(pattern) != text.rfind(pattern) and ( + self.Match_MaxBits == 0 + or len(pattern) < self.Match_MaxBits - self.Patch_Margin - self.Patch_Margin + ): + padding += self.Patch_Margin + pattern = text[ + max(0, patch.start2 - padding) : patch.start2 + patch.length1 + padding + ] + # Add one chunk for good luck. + padding += self.Patch_Margin - # Add the prefix. - prefix = text[max(0, patch.start2 - padding) : patch.start2] - if prefix: - patch.diffs[:0] = [(self.DIFF_EQUAL, prefix)] - # Add the suffix. - suffix = text[patch.start2 + patch.length1 : - patch.start2 + patch.length1 + padding] - if suffix: - patch.diffs.append((self.DIFF_EQUAL, suffix)) + # Add the prefix. + prefix = text[max(0, patch.start2 - padding) : patch.start2] + if prefix: + patch.diffs[:0] = [(self.DIFF_EQUAL, prefix)] + # Add the suffix. + suffix = text[ + patch.start2 + patch.length1 : patch.start2 + patch.length1 + padding + ] + if suffix: + patch.diffs.append((self.DIFF_EQUAL, suffix)) - # Roll back the start points. - patch.start1 -= len(prefix) - patch.start2 -= len(prefix) - # Extend lengths. - patch.length1 += len(prefix) + len(suffix) - patch.length2 += len(prefix) + len(suffix) + # Roll back the start points. + patch.start1 -= len(prefix) + patch.start2 -= len(prefix) + # Extend lengths. + patch.length1 += len(prefix) + len(suffix) + patch.length2 += len(prefix) + len(suffix) - def patch_make(self, a, b=None, c=None): - """Compute a list of patches to turn text1 into text2. - Use diffs if provided, otherwise compute it ourselves. - There are four ways to call this function, depending on what data is - available to the caller: - Method 1: - a = text1, b = text2 - Method 2: - a = diffs - Method 3 (optimal): - a = text1, b = diffs - Method 4 (deprecated, use method 3): - a = text1, b = text2, c = diffs + def patch_make(self, a, b=None, c=None): + """Compute a list of patches to turn text1 into text2. + Use diffs if provided, otherwise compute it ourselves. + There are four ways to call this function, depending on what data is + available to the caller: + Method 1: + a = text1, b = text2 + Method 2: + a = diffs + Method 3 (optimal): + a = text1, b = diffs + Method 4 (deprecated, use method 3): + a = text1, b = text2, c = diffs - Args: - a: text1 (methods 1,3,4) or Array of diff tuples for text1 to - text2 (method 2). - b: text2 (methods 1,4) or Array of diff tuples for text1 to - text2 (method 3) or undefined (method 2). - c: Array of diff tuples for text1 to text2 (method 4) or - undefined (methods 1,2,3). + Args: + a: text1 (methods 1,3,4) or Array of diff tuples for text1 to + text2 (method 2). + b: text2 (methods 1,4) or Array of diff tuples for text1 to + text2 (method 3) or undefined (method 2). + c: Array of diff tuples for text1 to text2 (method 4) or + undefined (methods 1,2,3). - Returns: - Array of Patch objects. - """ - text1 = None - diffs = None - # Note that texts may arrive as 'str' or 'unicode'. - if isinstance(a, str) and isinstance(b, str) and c is None: - # Method 1: text1, text2 - # Compute diffs from text1 and text2. - text1 = a - diffs = self.diff_main(text1, b, True) - if len(diffs) > 2: - self.diff_cleanupSemantic(diffs) - self.diff_cleanupEfficiency(diffs) - elif isinstance(a, list) and b is None and c is None: - # Method 2: diffs - # Compute text1 from diffs. - diffs = a - text1 = self.diff_text1(diffs) - elif isinstance(a, str) and isinstance(b, list) and c is None: - # Method 3: text1, diffs - text1 = a - diffs = b - elif (isinstance(a, str) and isinstance(b, str) and - isinstance(c, list)): - # Method 4: text1, text2, diffs - # text2 is not used. - text1 = a - diffs = c - else: - raise ValueError("Unknown call format to patch_make.") + Returns: + Array of Patch objects. + """ + text1 = None + diffs = None + # Note that texts may arrive as 'str' or 'unicode'. + if isinstance(a, str) and isinstance(b, str) and c is None: + # Method 1: text1, text2 + # Compute diffs from text1 and text2. + text1 = a + diffs = self.diff_main(text1, b, True) + if len(diffs) > 2: + self.diff_cleanupSemantic(diffs) + self.diff_cleanupEfficiency(diffs) + elif isinstance(a, list) and b is None and c is None: + # Method 2: diffs + # Compute text1 from diffs. + diffs = a + text1 = self.diff_text1(diffs) + elif isinstance(a, str) and isinstance(b, list) and c is None: + # Method 3: text1, diffs + text1 = a + diffs = b + elif isinstance(a, str) and isinstance(b, str) and isinstance(c, list): + # Method 4: text1, text2, diffs + # text2 is not used. + text1 = a + diffs = c + else: + raise ValueError("Unknown call format to patch_make.") - if not diffs: - return [] # Get rid of the None case. - patches = [] - patch = patch_obj() - char_count1 = 0 # Number of characters into the text1 string. - char_count2 = 0 # Number of characters into the text2 string. - prepatch_text = text1 # Recreate the patches to determine context info. - postpatch_text = text1 - for x in range(len(diffs)): - (diff_type, diff_text) = diffs[x] - if len(patch.diffs) == 0 and diff_type != self.DIFF_EQUAL: - # A new patch starts here. - patch.start1 = char_count1 - patch.start2 = char_count2 - if diff_type == self.DIFF_INSERT: - # Insertion - patch.diffs.append(diffs[x]) - patch.length2 += len(diff_text) - postpatch_text = (postpatch_text[:char_count2] + diff_text + - postpatch_text[char_count2:]) - elif diff_type == self.DIFF_DELETE: - # Deletion. - patch.length1 += len(diff_text) - patch.diffs.append(diffs[x]) - postpatch_text = (postpatch_text[:char_count2] + - postpatch_text[char_count2 + len(diff_text):]) - elif (diff_type == self.DIFF_EQUAL and - len(diff_text) <= 2 * self.Patch_Margin and - len(patch.diffs) != 0 and len(diffs) != x + 1): - # Small equality inside a patch. - patch.diffs.append(diffs[x]) - patch.length1 += len(diff_text) - patch.length2 += len(diff_text) + if not diffs: + return [] # Get rid of the None case. + patches = [] + patch = patch_obj() + char_count1 = 0 # Number of characters into the text1 string. + char_count2 = 0 # Number of characters into the text2 string. + prepatch_text = text1 # Recreate the patches to determine context info. + postpatch_text = text1 + for x in range(len(diffs)): + (diff_type, diff_text) = diffs[x] + if len(patch.diffs) == 0 and diff_type != self.DIFF_EQUAL: + # A new patch starts here. + patch.start1 = char_count1 + patch.start2 = char_count2 + if diff_type == self.DIFF_INSERT: + # Insertion + patch.diffs.append(diffs[x]) + patch.length2 += len(diff_text) + postpatch_text = ( + postpatch_text[:char_count2] + + diff_text + + postpatch_text[char_count2:] + ) + elif diff_type == self.DIFF_DELETE: + # Deletion. + patch.length1 += len(diff_text) + patch.diffs.append(diffs[x]) + postpatch_text = ( + postpatch_text[:char_count2] + + postpatch_text[char_count2 + len(diff_text) :] + ) + elif ( + diff_type == self.DIFF_EQUAL + and len(diff_text) <= 2 * self.Patch_Margin + and len(patch.diffs) != 0 + and len(diffs) != x + 1 + ): + # Small equality inside a patch. + patch.diffs.append(diffs[x]) + patch.length1 += len(diff_text) + patch.length2 += len(diff_text) - if (diff_type == self.DIFF_EQUAL and - len(diff_text) >= 2 * self.Patch_Margin): - # Time for a new patch. - if len(patch.diffs) != 0: - self.patch_addContext(patch, prepatch_text) - patches.append(patch) - patch = patch_obj() - # Unlike Unidiff, our patch lists have a rolling context. - # http://code.google.com/p/google-diff-match-patch/wiki/Unidiff - # Update prepatch text & pos to reflect the application of the - # just completed patch. - prepatch_text = postpatch_text - char_count1 = char_count2 + if diff_type == self.DIFF_EQUAL and len(diff_text) >= 2 * self.Patch_Margin: + # Time for a new patch. + if len(patch.diffs) != 0: + self.patch_addContext(patch, prepatch_text) + patches.append(patch) + patch = patch_obj() + # Unlike Unidiff, our patch lists have a rolling context. + # http://code.google.com/p/google-diff-match-patch/wiki/Unidiff + # Update prepatch text & pos to reflect the application of the + # just completed patch. + prepatch_text = postpatch_text + char_count1 = char_count2 - # Update the current character count. - if diff_type != self.DIFF_INSERT: - char_count1 += len(diff_text) - if diff_type != self.DIFF_DELETE: - char_count2 += len(diff_text) + # Update the current character count. + if diff_type != self.DIFF_INSERT: + char_count1 += len(diff_text) + if diff_type != self.DIFF_DELETE: + char_count2 += len(diff_text) - # Pick up the leftover patch if not empty. - if len(patch.diffs) != 0: - self.patch_addContext(patch, prepatch_text) - patches.append(patch) - return patches + # Pick up the leftover patch if not empty. + if len(patch.diffs) != 0: + self.patch_addContext(patch, prepatch_text) + patches.append(patch) + return patches - def patch_deepCopy(self, patches): - """Given an array of patches, return another array that is identical. + def patch_deepCopy(self, patches): + """Given an array of patches, return another array that is identical. - Args: - patches: Array of Patch objects. + Args: + patches: Array of Patch objects. - Returns: - Array of Patch objects. - """ - patchesCopy = [] - for patch in patches: - patchCopy = patch_obj() - # No need to deep copy the tuples since they are immutable. - patchCopy.diffs = patch.diffs[:] - patchCopy.start1 = patch.start1 - patchCopy.start2 = patch.start2 - patchCopy.length1 = patch.length1 - patchCopy.length2 = patch.length2 - patchesCopy.append(patchCopy) - return patchesCopy + Returns: + Array of Patch objects. + """ + patchesCopy = [] + for patch in patches: + patchCopy = patch_obj() + # No need to deep copy the tuples since they are immutable. + patchCopy.diffs = patch.diffs[:] + patchCopy.start1 = patch.start1 + patchCopy.start2 = patch.start2 + patchCopy.length1 = patch.length1 + patchCopy.length2 = patch.length2 + patchesCopy.append(patchCopy) + return patchesCopy - def patch_apply(self, patches, text): - """Merge a set of patches onto the text. Return a patched text, as well - as a list of true/false values indicating which patches were applied. + def patch_apply(self, patches, text): + """Merge a set of patches onto the text. Return a patched text, as well + as a list of true/false values indicating which patches were applied. - Args: - patches: Array of Patch objects. - text: Old text. + Args: + patches: Array of Patch objects. + text: Old text. - Returns: - Two element Array, containing the new text and an array of boolean values. - """ - if not patches: - return (text, []) + Returns: + Two element Array, containing the new text and an array of boolean values. + """ + if not patches: + return (text, []) - # Deep copy the patches so that no changes are made to originals. - patches = self.patch_deepCopy(patches) + # Deep copy the patches so that no changes are made to originals. + patches = self.patch_deepCopy(patches) - nullPadding = self.patch_addPadding(patches) - text = nullPadding + text + nullPadding - self.patch_splitMax(patches) + nullPadding = self.patch_addPadding(patches) + text = nullPadding + text + nullPadding + self.patch_splitMax(patches) - # delta keeps track of the offset between the expected and actual location - # of the previous patch. If there are patches expected at positions 10 and - # 20, but the first patch was found at 12, delta is 2 and the second patch - # has an effective expected position of 22. - delta = 0 - results = [] - for patch in patches: - expected_loc = patch.start2 + delta - text1 = self.diff_text1(patch.diffs) - end_loc = -1 - if len(text1) > self.Match_MaxBits: - # patch_splitMax will only provide an oversized pattern in the case of - # a monster delete. - start_loc = self.match_main(text, text1[:self.Match_MaxBits], - expected_loc) - if start_loc != -1: - end_loc = self.match_main(text, text1[-self.Match_MaxBits:], - expected_loc + len(text1) - self.Match_MaxBits) - if end_loc == -1 or start_loc >= end_loc: - # Can't find valid trailing context. Drop this patch. - start_loc = -1 - else: - start_loc = self.match_main(text, text1, expected_loc) - if start_loc == -1: - # No match found. :( - results.append(False) - # Subtract the delta for this failed patch from subsequent patches. - delta -= patch.length2 - patch.length1 - else: - # Found a match. :) - results.append(True) - delta = start_loc - expected_loc - if end_loc == -1: - text2 = text[start_loc : start_loc + len(text1)] - else: - text2 = text[start_loc : end_loc + self.Match_MaxBits] - if text1 == text2: - # Perfect match, just shove the replacement text in. - text = (text[:start_loc] + self.diff_text2(patch.diffs) + - text[start_loc + len(text1):]) - else: - # Imperfect match. - # Run a diff to get a framework of equivalent indices. - diffs = self.diff_main(text1, text2, False) - if (len(text1) > self.Match_MaxBits and - self.diff_levenshtein(diffs) / float(len(text1)) > - self.Patch_DeleteThreshold): - # The end points match, but the content is unacceptably bad. - results[-1] = False - else: - self.diff_cleanupSemanticLossless(diffs) - index1 = 0 - for (op, data) in patch.diffs: - if op != self.DIFF_EQUAL: - index2 = self.diff_xIndex(diffs, index1) - if op == self.DIFF_INSERT: # Insertion - text = text[:start_loc + index2] + data + text[start_loc + - index2:] - elif op == self.DIFF_DELETE: # Deletion - text = text[:start_loc + index2] + text[start_loc + - self.diff_xIndex(diffs, index1 + len(data)):] - if op != self.DIFF_DELETE: - index1 += len(data) - # Strip the padding off. - text = text[len(nullPadding):-len(nullPadding)] - return (text, results) + # delta keeps track of the offset between the expected and actual location + # of the previous patch. If there are patches expected at positions 10 and + # 20, but the first patch was found at 12, delta is 2 and the second patch + # has an effective expected position of 22. + delta = 0 + results = [] + for patch in patches: + expected_loc = patch.start2 + delta + text1 = self.diff_text1(patch.diffs) + end_loc = -1 + if len(text1) > self.Match_MaxBits: + # patch_splitMax will only provide an oversized pattern in the case of + # a monster delete. + start_loc = self.match_main( + text, text1[: self.Match_MaxBits], expected_loc + ) + if start_loc != -1: + end_loc = self.match_main( + text, + text1[-self.Match_MaxBits :], + expected_loc + len(text1) - self.Match_MaxBits, + ) + if end_loc == -1 or start_loc >= end_loc: + # Can't find valid trailing context. Drop this patch. + start_loc = -1 + else: + start_loc = self.match_main(text, text1, expected_loc) + if start_loc == -1: + # No match found. :( + results.append(False) + # Subtract the delta for this failed patch from subsequent patches. + delta -= patch.length2 - patch.length1 + else: + # Found a match. :) + results.append(True) + delta = start_loc - expected_loc + if end_loc == -1: + text2 = text[start_loc : start_loc + len(text1)] + else: + text2 = text[start_loc : end_loc + self.Match_MaxBits] + if text1 == text2: + # Perfect match, just shove the replacement text in. + text = ( + text[:start_loc] + + self.diff_text2(patch.diffs) + + text[start_loc + len(text1) :] + ) + else: + # Imperfect match. + # Run a diff to get a framework of equivalent indices. + diffs = self.diff_main(text1, text2, False) + if ( + len(text1) > self.Match_MaxBits + and self.diff_levenshtein(diffs) / float(len(text1)) + > self.Patch_DeleteThreshold + ): + # The end points match, but the content is unacceptably bad. + results[-1] = False + else: + self.diff_cleanupSemanticLossless(diffs) + index1 = 0 + for op, data in patch.diffs: + if op != self.DIFF_EQUAL: + index2 = self.diff_xIndex(diffs, index1) + if op == self.DIFF_INSERT: # Insertion + text = ( + text[: start_loc + index2] + + data + + text[start_loc + index2 :] + ) + elif op == self.DIFF_DELETE: # Deletion + text = ( + text[: start_loc + index2] + + text[ + start_loc + + self.diff_xIndex(diffs, index1 + len(data)) : + ] + ) + if op != self.DIFF_DELETE: + index1 += len(data) + # Strip the padding off. + text = text[len(nullPadding) : -len(nullPadding)] + return (text, results) - def patch_addPadding(self, patches): - """Add some padding on text start and end so that edges can match - something. Intended to be called only from within patch_apply. + def patch_addPadding(self, patches): + """Add some padding on text start and end so that edges can match + something. Intended to be called only from within patch_apply. - Args: - patches: Array of Patch objects. + Args: + patches: Array of Patch objects. - Returns: - The padding string added to each side. - """ - paddingLength = self.Patch_Margin - nullPadding = "" - for x in range(1, paddingLength + 1): - nullPadding += chr(x) + Returns: + The padding string added to each side. + """ + paddingLength = self.Patch_Margin + nullPadding = "" + for x in range(1, paddingLength + 1): + nullPadding += chr(x) - # Bump all the patches forward. - for patch in patches: - patch.start1 += paddingLength - patch.start2 += paddingLength + # Bump all the patches forward. + for patch in patches: + patch.start1 += paddingLength + patch.start2 += paddingLength - # Add some padding on start of first diff. - patch = patches[0] - diffs = patch.diffs - if not diffs or diffs[0][0] != self.DIFF_EQUAL: - # Add nullPadding equality. - diffs.insert(0, (self.DIFF_EQUAL, nullPadding)) - patch.start1 -= paddingLength # Should be 0. - patch.start2 -= paddingLength # Should be 0. - patch.length1 += paddingLength - patch.length2 += paddingLength - elif paddingLength > len(diffs[0][1]): - # Grow first equality. - extraLength = paddingLength - len(diffs[0][1]) - newText = nullPadding[len(diffs[0][1]):] + diffs[0][1] - diffs[0] = (diffs[0][0], newText) - patch.start1 -= extraLength - patch.start2 -= extraLength - patch.length1 += extraLength - patch.length2 += extraLength + # Add some padding on start of first diff. + patch = patches[0] + diffs = patch.diffs + if not diffs or diffs[0][0] != self.DIFF_EQUAL: + # Add nullPadding equality. + diffs.insert(0, (self.DIFF_EQUAL, nullPadding)) + patch.start1 -= paddingLength # Should be 0. + patch.start2 -= paddingLength # Should be 0. + patch.length1 += paddingLength + patch.length2 += paddingLength + elif paddingLength > len(diffs[0][1]): + # Grow first equality. + extraLength = paddingLength - len(diffs[0][1]) + newText = nullPadding[len(diffs[0][1]) :] + diffs[0][1] + diffs[0] = (diffs[0][0], newText) + patch.start1 -= extraLength + patch.start2 -= extraLength + patch.length1 += extraLength + patch.length2 += extraLength - # Add some padding on end of last diff. - patch = patches[-1] - diffs = patch.diffs - if not diffs or diffs[-1][0] != self.DIFF_EQUAL: - # Add nullPadding equality. - diffs.append((self.DIFF_EQUAL, nullPadding)) - patch.length1 += paddingLength - patch.length2 += paddingLength - elif paddingLength > len(diffs[-1][1]): - # Grow last equality. - extraLength = paddingLength - len(diffs[-1][1]) - newText = diffs[-1][1] + nullPadding[:extraLength] - diffs[-1] = (diffs[-1][0], newText) - patch.length1 += extraLength - patch.length2 += extraLength + # Add some padding on end of last diff. + patch = patches[-1] + diffs = patch.diffs + if not diffs or diffs[-1][0] != self.DIFF_EQUAL: + # Add nullPadding equality. + diffs.append((self.DIFF_EQUAL, nullPadding)) + patch.length1 += paddingLength + patch.length2 += paddingLength + elif paddingLength > len(diffs[-1][1]): + # Grow last equality. + extraLength = paddingLength - len(diffs[-1][1]) + newText = diffs[-1][1] + nullPadding[:extraLength] + diffs[-1] = (diffs[-1][0], newText) + patch.length1 += extraLength + patch.length2 += extraLength - return nullPadding + return nullPadding - def patch_splitMax(self, patches): - """Look through the patches and break up any which are longer than the - maximum limit of the match algorithm. - Intended to be called only from within patch_apply. + def patch_splitMax(self, patches): + """Look through the patches and break up any which are longer than the + maximum limit of the match algorithm. + Intended to be called only from within patch_apply. - Args: - patches: Array of Patch objects. - """ - patch_size = self.Match_MaxBits - if patch_size == 0: - # Python has the option of not splitting strings due to its ability - # to handle integers of arbitrary precision. - return - for x in range(len(patches)): - if patches[x].length1 <= patch_size: - continue - bigpatch = patches[x] - # Remove the big old patch. - del patches[x] - x -= 1 - start1 = bigpatch.start1 - start2 = bigpatch.start2 - precontext = '' - while len(bigpatch.diffs) != 0: - # Create one of several smaller patches. - patch = patch_obj() - empty = True - patch.start1 = start1 - len(precontext) - patch.start2 = start2 - len(precontext) - if precontext: - patch.length1 = patch.length2 = len(precontext) - patch.diffs.append((self.DIFF_EQUAL, precontext)) + Args: + patches: Array of Patch objects. + """ + patch_size = self.Match_MaxBits + if patch_size == 0: + # Python has the option of not splitting strings due to its ability + # to handle integers of arbitrary precision. + return + for x in range(len(patches)): + if patches[x].length1 <= patch_size: + continue + bigpatch = patches[x] + # Remove the big old patch. + del patches[x] + x -= 1 + start1 = bigpatch.start1 + start2 = bigpatch.start2 + precontext = "" + while len(bigpatch.diffs) != 0: + # Create one of several smaller patches. + patch = patch_obj() + empty = True + patch.start1 = start1 - len(precontext) + patch.start2 = start2 - len(precontext) + if precontext: + patch.length1 = patch.length2 = len(precontext) + patch.diffs.append((self.DIFF_EQUAL, precontext)) - while (len(bigpatch.diffs) != 0 and - patch.length1 < patch_size - self.Patch_Margin): - (diff_type, diff_text) = bigpatch.diffs[0] - if diff_type == self.DIFF_INSERT: - # Insertions are harmless. - patch.length2 += len(diff_text) - start2 += len(diff_text) - patch.diffs.append(bigpatch.diffs.pop(0)) - empty = False - elif (diff_type == self.DIFF_DELETE and len(patch.diffs) == 1 and - patch.diffs[0][0] == self.DIFF_EQUAL and - len(diff_text) > 2 * patch_size): - # This is a large deletion. Let it pass in one chunk. - patch.length1 += len(diff_text) - start1 += len(diff_text) - empty = False - patch.diffs.append((diff_type, diff_text)) - del bigpatch.diffs[0] - else: - # Deletion or equality. Only take as much as we can stomach. - diff_text = diff_text[:patch_size - patch.length1 - - self.Patch_Margin] - patch.length1 += len(diff_text) - start1 += len(diff_text) - if diff_type == self.DIFF_EQUAL: - patch.length2 += len(diff_text) - start2 += len(diff_text) - else: - empty = False + while ( + len(bigpatch.diffs) != 0 + and patch.length1 < patch_size - self.Patch_Margin + ): + (diff_type, diff_text) = bigpatch.diffs[0] + if diff_type == self.DIFF_INSERT: + # Insertions are harmless. + patch.length2 += len(diff_text) + start2 += len(diff_text) + patch.diffs.append(bigpatch.diffs.pop(0)) + empty = False + elif ( + diff_type == self.DIFF_DELETE + and len(patch.diffs) == 1 + and patch.diffs[0][0] == self.DIFF_EQUAL + and len(diff_text) > 2 * patch_size + ): + # This is a large deletion. Let it pass in one chunk. + patch.length1 += len(diff_text) + start1 += len(diff_text) + empty = False + patch.diffs.append((diff_type, diff_text)) + del bigpatch.diffs[0] + else: + # Deletion or equality. Only take as much as we can stomach. + diff_text = diff_text[ + : patch_size - patch.length1 - self.Patch_Margin + ] + patch.length1 += len(diff_text) + start1 += len(diff_text) + if diff_type == self.DIFF_EQUAL: + patch.length2 += len(diff_text) + start2 += len(diff_text) + else: + empty = False - patch.diffs.append((diff_type, diff_text)) - if diff_text == bigpatch.diffs[0][1]: - del bigpatch.diffs[0] - else: - bigpatch.diffs[0] = (bigpatch.diffs[0][0], - bigpatch.diffs[0][1][len(diff_text):]) + patch.diffs.append((diff_type, diff_text)) + if diff_text == bigpatch.diffs[0][1]: + del bigpatch.diffs[0] + else: + bigpatch.diffs[0] = ( + bigpatch.diffs[0][0], + bigpatch.diffs[0][1][len(diff_text) :], + ) - # Compute the head context for the next patch. - precontext = self.diff_text2(patch.diffs) - precontext = precontext[-self.Patch_Margin:] - # Append the end context for this patch. - postcontext = self.diff_text1(bigpatch.diffs)[:self.Patch_Margin] - if postcontext: - patch.length1 += len(postcontext) - patch.length2 += len(postcontext) - if len(patch.diffs) != 0 and patch.diffs[-1][0] == self.DIFF_EQUAL: - patch.diffs[-1] = (self.DIFF_EQUAL, patch.diffs[-1][1] + - postcontext) - else: - patch.diffs.append((self.DIFF_EQUAL, postcontext)) + # Compute the head context for the next patch. + precontext = self.diff_text2(patch.diffs) + precontext = precontext[-self.Patch_Margin :] + # Append the end context for this patch. + postcontext = self.diff_text1(bigpatch.diffs)[: self.Patch_Margin] + if postcontext: + patch.length1 += len(postcontext) + patch.length2 += len(postcontext) + if len(patch.diffs) != 0 and patch.diffs[-1][0] == self.DIFF_EQUAL: + patch.diffs[-1] = ( + self.DIFF_EQUAL, + patch.diffs[-1][1] + postcontext, + ) + else: + patch.diffs.append((self.DIFF_EQUAL, postcontext)) - if not empty: - x += 1 - patches.insert(x, patch) - - def patch_toText(self, patches): - """Take a list of patches and return a textual representation. + if not empty: + x += 1 + patches.insert(x, patch) - Args: - patches: Array of Patch objects. + def patch_toText(self, patches): + """Take a list of patches and return a textual representation. + + Args: + patches: Array of Patch objects. - Returns: - Text representation of patches. - """ - text = [] - for patch in patches: - text.append(str(patch)) - return "".join(text) + Returns: + Text representation of patches. + """ + text = [] + for patch in patches: + text.append(str(patch)) + return "".join(text) - def patch_fromText(self, textline): - """Parse a textual representation of patches and return a list of patch - objects. + def patch_fromText(self, textline): + """Parse a textual representation of patches and return a list of patch + objects. - Args: - textline: Text representation of patches. + Args: + textline: Text representation of patches. - Returns: - Array of Patch objects. + Returns: + Array of Patch objects. - Raises: - ValueError: If invalid input. - """ - if type(textline) == unicode: - # Patches should be composed of a subset of ascii chars, Unicode not - # required. If this encode raises UnicodeEncodeError, patch is invalid. - textline = textline.encode("ascii") - patches = [] - if not textline: - return patches - text = textline.split('\n') - while len(text) != 0: - m = re.match("^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@$", text[0]) - if not m: - raise ValueError("Invalid patch string: " + text[0]) - patch = patch_obj() - patches.append(patch) - patch.start1 = int(m.group(1)) - if m.group(2) == '': - patch.start1 -= 1 - patch.length1 = 1 - elif m.group(2) == '0': - patch.length1 = 0 - else: - patch.start1 -= 1 - patch.length1 = int(m.group(2)) + Raises: + ValueError: If invalid input. + """ + if type(textline) == unicode: + # Patches should be composed of a subset of ascii chars, Unicode not + # required. If this encode raises UnicodeEncodeError, patch is invalid. + textline = textline.encode("ascii") + patches = [] + if not textline: + return patches + text = textline.split("\n") + while len(text) != 0: + m = re.match("^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@$", text[0]) + if not m: + raise ValueError("Invalid patch string: " + text[0]) + patch = patch_obj() + patches.append(patch) + patch.start1 = int(m.group(1)) + if m.group(2) == "": + patch.start1 -= 1 + patch.length1 = 1 + elif m.group(2) == "0": + patch.length1 = 0 + else: + patch.start1 -= 1 + patch.length1 = int(m.group(2)) - patch.start2 = int(m.group(3)) - if m.group(4) == '': - patch.start2 -= 1 - patch.length2 = 1 - elif m.group(4) == '0': - patch.length2 = 0 - else: - patch.start2 -= 1 - patch.length2 = int(m.group(4)) + patch.start2 = int(m.group(3)) + if m.group(4) == "": + patch.start2 -= 1 + patch.length2 = 1 + elif m.group(4) == "0": + patch.length2 = 0 + else: + patch.start2 -= 1 + patch.length2 = int(m.group(4)) - del text[0] + del text[0] - while len(text) != 0: - if text[0]: - sign = text[0][0] - else: - sign = '' - line = urllib.parse.unquote(text[0][1:]) - line = line.decode("utf-8") - if sign == '+': - # Insertion. - patch.diffs.append((self.DIFF_INSERT, line)) - elif sign == '-': - # Deletion. - patch.diffs.append((self.DIFF_DELETE, line)) - elif sign == ' ': - # Minor equality. - patch.diffs.append((self.DIFF_EQUAL, line)) - elif sign == '@': - # Start of next patch. - break - elif sign == '': - # Blank line? Whatever. - pass - else: - # WTF? - raise ValueError("Invalid patch mode: '%s'\n%s" % (sign, line)) - del text[0] - return patches + while len(text) != 0: + if text[0]: + sign = text[0][0] + else: + sign = "" + line = urllib.parse.unquote(text[0][1:]) + line = line.decode("utf-8") + if sign == "+": + # Insertion. + patch.diffs.append((self.DIFF_INSERT, line)) + elif sign == "-": + # Deletion. + patch.diffs.append((self.DIFF_DELETE, line)) + elif sign == " ": + # Minor equality. + patch.diffs.append((self.DIFF_EQUAL, line)) + elif sign == "@": + # Start of next patch. + break + elif sign == "": + # Blank line? Whatever. + pass + else: + # WTF? + raise ValueError("Invalid patch mode: '%s'\n%s" % (sign, line)) + del text[0] + return patches class patch_obj: - """Class representing one patch operation. - """ + """Class representing one patch operation.""" - def __init__(self): - """Initializes with an empty list of diffs. - """ - self.diffs = [] - self.start1 = None - self.start2 = None - self.length1 = 0 - self.length2 = 0 + def __init__(self): + """Initializes with an empty list of diffs.""" + self.diffs = [] + self.start1 = None + self.start2 = None + self.length1 = 0 + self.length2 = 0 - def __str__(self): - """Emmulate GNU diff's format. - Header: @@ -382,8 +481,9 @@ - Indicies are printed as 1-based, not 0-based. + def __str__(self): + """Emmulate GNU diff's format. + Header: @@ -382,8 +481,9 @@ + Indicies are printed as 1-based, not 0-based. - Returns: - The GNU diff string. - """ - if self.length1 == 0: - coords1 = str(self.start1) + ",0" - elif self.length1 == 1: - coords1 = str(self.start1 + 1) - else: - coords1 = str(self.start1 + 1) + "," + str(self.length1) - if self.length2 == 0: - coords2 = str(self.start2) + ",0" - elif self.length2 == 1: - coords2 = str(self.start2 + 1) - else: - coords2 = str(self.start2 + 1) + "," + str(self.length2) - text = ["@@ -", coords1, " +", coords2, " @@\n"] - # Escape the body of the patch with %xx notation. - for (op, data) in self.diffs: - if op == diff_match_patch.DIFF_INSERT: - text.append("+") - elif op == diff_match_patch.DIFF_DELETE: - text.append("-") - elif op == diff_match_patch.DIFF_EQUAL: - text.append(" ") - # High ascii will raise UnicodeDecodeError. Use Unicode instead. - data = data.encode("utf-8") - text.append(urllib.parse.quote(data, "!~*'();/?:@&=+$,# ") + "\n") - return "".join(text) \ No newline at end of file + Returns: + The GNU diff string. + """ + if self.length1 == 0: + coords1 = str(self.start1) + ",0" + elif self.length1 == 1: + coords1 = str(self.start1 + 1) + else: + coords1 = str(self.start1 + 1) + "," + str(self.length1) + if self.length2 == 0: + coords2 = str(self.start2) + ",0" + elif self.length2 == 1: + coords2 = str(self.start2 + 1) + else: + coords2 = str(self.start2 + 1) + "," + str(self.length2) + text = ["@@ -", coords1, " +", coords2, " @@\n"] + # Escape the body of the patch with %xx notation. + for op, data in self.diffs: + if op == diff_match_patch.DIFF_INSERT: + text.append("+") + elif op == diff_match_patch.DIFF_DELETE: + text.append("-") + elif op == diff_match_patch.DIFF_EQUAL: + text.append(" ") + # High ascii will raise UnicodeDecodeError. Use Unicode instead. + data = data.encode("utf-8") + text.append(urllib.parse.quote(data, "!~*'();/?:@&=+$,# ") + "\n") + return "".join(text)