#!/usr/bin/python2.4

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