~widelands-dev/widelands-website/django_staticfiles

#!/usr/bin/python2.4

# Taken from google because they do not provide a setup.py file. Thanks anyway

"""Diff Match and Patch.

Copyright 2006 Google Inc.

http://code.google.com/p/google-diff-match-patch/

Licensed under the Apache License, Version 2.0 (the "License");

you may not use this file except in compliance with the License.

You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software

distributed under the License is distributed on an "AS IS" BASIS,

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

See the License for the specific language governing permissions and

limitations under the License.

"""

"""Functions for diff, match and patch.

Computes the difference between two texts to create a patch.

Applies the patch onto another text, allowing for errors.

"""

__author__ = 'fraser@google.com (Neil Fraser)'

import math

import time

import urllib

import re

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

        # The size beyond which the double-ended diff activates.

        # Double-ending is twice as fast, but less accurate.

        self.Diff_DualThreshold = 32

        # 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 does

        # the contents have 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

        # How many bits in a number?

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

        """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.

        Returns:

          Array of changes.

        """

        # Check for equality (speedup)

        if text1 == text2:

            return [(self.DIFF_EQUAL, text1)]

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

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

        """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.

        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

        longtext = shorttext = None  # Garbage collect.

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

            diffs_b = self.diff_main(text1_b, text2_b, checklines)

            # Merge the results.

            return diffs_a + [(self.DIFF_EQUAL, mid_common)] + diffs_b

        # Perform a real diff.

        if checklines and (len(text1) < 100 or len(text2) < 100):

            checklines = False  # Too trivial for the overhead.

        if checklines:

            # Scan the text on a line-by-line basis first.

            (text1, text2, linearray) = self.diff_linesToChars(text1, text2)

        diffs = self.diff_map(text1, text2)

        if not diffs:  # No acceptable result.

            diffs = [(self.DIFF_DELETE, text1), (self.DIFF_INSERT, text2)]

        if checklines:

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

                        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_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(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 xrange(len(diffs)):

            text = []

            for char in diffs[x][1]:

                text.append(lineArray[ord(char)])

            diffs[x] = (diffs[x][0], ''.join(text))

    def diff_map(self, text1, text2):

        """Explore the intersection points between the two texts.

        Args:

          text1: Old string to be diffed.

          text2: New string to be diffed.

        Returns:

          Array of diff tuples or None if no diff available.

        """

        # Unlike in most languages, Python counts time in seconds.

        s_end = time.time() + self.Diff_Timeout  # Don't run for too long.

        # Cache the text lengths to prevent multiple calls.

        text1_length = len(text1)

        text2_length = len(text2)

        max_d = text1_length + text2_length - 1

        doubleEnd = self.Diff_DualThreshold * 2 < max_d

        v_map1 = []

        v_map2 = []

        v1 = {}

        v2 = {}

        v1[1] = 0

        v2[1] = 0

        footsteps = {}

        done = False

        # If the total number of characters is odd, then the front path will

        # collide with the reverse path.

        front = (text1_length + text2_length) % 2

        for d in xrange(max_d):

            # Bail out if timeout reached.

            if self.Diff_Timeout > 0 and time.time() > s_end:

                return None

            # Walk the front path one step.

            v_map1.append({})

            for k in xrange(-d, d + 1, 2):

                if k == -d or k != d and v1[k - 1] < v1[k + 1]:

                    x = v1[k + 1]

                else:

                    x = v1[k - 1] + 1

                y = x - k

                if doubleEnd:

                    footstep = (x, y)

                    if front and footstep in footsteps:

                        done = True

                    if not front:

                        footsteps[footstep] = d

                while (not done and x < text1_length and y < text2_length and

                       text1[x] == text2[y]):

                    x += 1

                    y += 1

                    if doubleEnd:

                        footstep = (x, y)

                        if front and footstep in footsteps:

                            done = True

                        if not front:

                            footsteps[footstep] = d

                v1[k] = x

                v_map1[d][(x, y)] = True

                if x == text1_length and y == text2_length:

                    # Reached the end in single-path mode.

                    return self.diff_path1(v_map1, text1, text2)

                elif done:

                    # Front path ran over reverse path.

                    v_map2 = v_map2[:footsteps[footstep] + 1]

                    a = self.diff_path1(v_map1, text1[:x], text2[:y])

                    b = self.diff_path2(v_map2, text1[x:], text2[y:])

                    return a + b

            if doubleEnd:

                # Walk the reverse path one step.

                v_map2.append({})

                for k in xrange(-d, d + 1, 2):

                    if k == -d or k != d and v2[k - 1] < v2[k + 1]:

                        x = v2[k + 1]

                    else:

                        x = v2[k - 1] + 1

                    y = x - k

                    footstep = (text1_length - x, text2_length - y)

                    if not front and footstep in footsteps:

                        done = True

                    if front:

                        footsteps[footstep] = d

                    while (not done and x < text1_length and y < text2_length and

                           text1[-x - 1] == text2[-y - 1]):

                        x += 1

                        y += 1

                        footstep = (text1_length - x, text2_length - y)

                        if not front and footstep in footsteps:

                            done = True

                        if front:

                            footsteps[footstep] = d

                    v2[k] = x

                    v_map2[d][(x, y)] = True

                    if done:

                        # Reverse path ran over front path.

                        v_map1 = v_map1[:footsteps[footstep] + 1]

                        a = self.diff_path1(v_map1, text1[:text1_length - x],

                                            text2[:text2_length - y])

                        b = self.diff_path2(v_map2, text1[text1_length - x:],

                                            text2[text2_length - y:])

                        return a + b

        # Number of diffs equals number of characters, no commonality at all.

        return None

    def diff_path1(self, v_map, text1, text2):

        """Work from the middle back to the start to determine the path.

        Args:

          v_map: Array of paths.

          text1: Old string fragment to be diffed.

          text2: New string fragment to be diffed.

        Returns:

          Array of diff tuples.

        """

        path = []

        x = len(text1)

        y = len(text2)

        last_op = None

        for d in xrange(len(v_map) - 2, -1, -1):

            while True:

                if (x - 1, y) in v_map[d]:

                    x -= 1

                    if last_op == self.DIFF_DELETE:

                        path[0] = (self.DIFF_DELETE, text1[x] + path[0][1])

                    else:

                        path[:0] = [(self.DIFF_DELETE, text1[x])]

                    last_op = self.DIFF_DELETE

                    break

                elif (x, y - 1) in v_map[d]:

                    y -= 1

                    if last_op == self.DIFF_INSERT:

                        path[0] = (self.DIFF_INSERT, text2[y] + path[0][1])

                    else:

                        path[:0] = [(self.DIFF_INSERT, text2[y])]

                    last_op = self.DIFF_INSERT

                    break

                else:

                    x -= 1

                    y -= 1

                    assert text1[x] == text2[y], ('No diagonal.  ' +

                                                  "Can't happen. (diff_path1)")

                    if last_op == self.DIFF_EQUAL:

                        path[0] = (self.DIFF_EQUAL, text1[x] + path[0][1])

                    else:

                        path[:0] = [(self.DIFF_EQUAL, text1[x])]

                    last_op = self.DIFF_EQUAL

        return path

    def diff_path2(self, v_map, text1, text2):

        """Work from the middle back to the end to determine the path.

        Args:

          v_map: Array of paths.

          text1: Old string fragment to be diffed.

          text2: New string fragment to be diffed.

        Returns:

          Array of diff tuples.

        """

        path = []

        x = len(text1)

        y = len(text2)

        last_op = None

        for d in xrange(len(v_map) - 2, -1, -1):

            while True:

                if (x - 1, y) in v_map[d]:

                    x -= 1

                    if last_op == self.DIFF_DELETE:

                        path[-1] = (self.DIFF_DELETE, path[-1]

                                    [1] + text1[-x - 1])

                    else:

                        path.append((self.DIFF_DELETE, text1[-x - 1]))

                    last_op = self.DIFF_DELETE

                    break

                elif (x, y - 1) in v_map[d]:

                    y -= 1

                    if last_op == self.DIFF_INSERT:

                        path[-1] = (self.DIFF_INSERT, path[-1]

                                    [1] + text2[-y - 1])

                    else:

                        path.append((self.DIFF_INSERT, text2[-y - 1]))

                    last_op = self.DIFF_INSERT

                    break

                else:

                    x -= 1

                    y -= 1

                    assert text1[-x - 1] == text2[-y - 1], ('No diagonal.  ' +

                                                            "Can't happen. (diff_path2)")

                    if last_op == self.DIFF_EQUAL:

                        path[-1] = (self.DIFF_EQUAL, path[-1]

                                    [1] + text1[-x - 1])

                    else:

                        path.append((self.DIFF_EQUAL, text1[-x - 1]))

                    last_op = self.DIFF_EQUAL

        return path

    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 = int((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 = int((pointermax - pointermin) / 2 + pointermin)

        return pointermid

    def diff_halfMatch(self, text1, text2):

        """Do the two texts share a substring which is at least half the length

        of the longer text?

        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 len(text1) > len(text2):

            (longtext, shorttext) = (text1, text2)

        else:

            (shorttext, longtext) = (text1, text2)

        if len(longtext) < 10 or len(shorttext) < 1:

            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) >= len(longtext) / 2:

                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 equalities[-1][1]

        pointer = 0  # Index of current position.

        # Number of chars that changed prior to the equality.

        length_changes1 = 0

        length_changes2 = 0  # Number of chars that changed after the equality.

        while pointer < len(diffs):

            if diffs[pointer][0] == self.DIFF_EQUAL:  # equality found

                equalities.append(pointer)

                length_changes1 = length_changes2

                length_changes2 = 0

                lastequality = diffs[pointer][1]

            else:  # an insertion or deletion

                length_changes2 += len(diffs[pointer][1])

                if (lastequality != None and (len(lastequality) <= length_changes1) and

                        (len(lastequality) <= length_changes2)):

                    # 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) != 0:

                        equalities.pop()

                    if len(equalities):

                        pointer = equalities[-1]

                    else:

                        pointer = -1

                    length_changes1 = 0  # Reset the counters.

                    length_changes2 = 0

                    lastequality = None

                    changes = True

            pointer += 1

        if changes:

            self.diff_cleanupMerge(diffs)

        self.diff_cleanupSemanticLossless(diffs)

    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 c<ins>at c</ins>ame. -> The <ins>cat </ins>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 5

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

            # 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.

            score = 0

            # One point for non-alphanumeric.

            if not one[-1].isalnum() or not two[0].isalnum():

                score += 1

                # Two points for whitespace.

                if one[-1].isspace() or two[0].isspace():

                    score += 1

                    # Three points for line breaks.

                    if (one[-1] == '\r' or one[-1] == '\n' or

                            two[0] == '\r' or two[0] == '\n'):

                        score += 1

                        # Four points for blank lines.

                        if (re.search('\\n\\r?\\n$', one) or

                                re.match('^\\r?\\n\\r?\\n', two)):

                            score += 1

            return score

        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]

                # First, shift the edit as far left as possible.

                commonOffset = self.diff_commonSuffix(equality1, edit)