diffmatchpatch Class Reference

Inheritance diagram for diffmatchpatch:

Collaboration diagram for diffmatchpatch:

Public Member Functions
def	diff_prettyText (self, diffs)
def	diff_linesToWords (self, text1, text2, delimiter=re.compile('\n'))

Detailed Description

Definition at line 139 of file utilities.py.

Member Function Documentation

diff_linesToWords()

def diff_linesToWords	(		self,
			text1,
			text2,
			delimiter = re.compile('\n')
	)

    Split two texts into an array of strings.  Reduce the texts to a string
    of hashes where each Unicode character represents one line.

    95% of this function code is copied from `diff_linesToChars` on:
        https://github.com/google/diff-match-patch/blob/895a9512bbcee0ac5a8ffcee36062c8a79f5dcda/python3/diff_match_patch.py#L381

    Copyright 2018 The diff-match-patch Authors.
    https://github.com/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

    Args:
        text1: First string.
        text2: Second string.
        delimiter: a re.compile() expression for the word delimiter type

    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.

Definition at line 216 of file utilities.py.

        def diff_linesToWords(self, text1, text2, delimiter=re.compile('\n')):
            """
                Split two texts into an array of strings.  Reduce the texts to a string
                of hashes where each Unicode character represents one line.

                95% of this function code is copied from `diff_linesToChars` on:
                    https://github.com/google/diff-match-patch/blob/895a9512bbcee0ac5a8ffcee36062c8a79f5dcda/python3/diff_match_patch.py#L381

                Copyright 2018 The diff-match-patch Authors.
                https://github.com/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

                Args:
                    text1: First string.
                    text2: Second string.
                    delimiter: a re.compile() expression for the word delimiter type

                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 = delimiter.search(text, lineStart)

                    if lineEnd:
                        lineEnd = lineEnd.start()

                    else:
                        lineEnd = len(text) - 1

                    line = text[lineStart:lineEnd + 1]

                    if line in lineHash:
                        chars.append(unichr(lineHash[line]))
                    else:
                        if len(lineArray) == maxLines:
                            # Bail out at maxLines because unichr(maxLines+1) throws.
                            line = text[lineStart:]
                            lineEnd = len(text)
                        lineArray.append(line)
                        lineHash[line] = len(lineArray) - 1
                        chars.append(unichr(len(lineArray) - 1))
                    lineStart = lineEnd + 1
                return "".join(chars)

            # Allocate 2/3rds of the space for text1, the rest for text2.
            maxLines = _g_maximum_lines
            chars1 = diff_linesToCharsMunge(text1)
            maxLines = _g_char_limit
            chars2 = diff_linesToCharsMunge(text2)
            return (chars1, chars2, lineArray)


# An unique identifier for any created object

diff_prettyText()

def diff_prettyText	(		self,
			diffs
	)

Convert a diff array into a pretty Text report.
Args:
  diffs: Array of diff tuples.
Returns:
  Text representation.

Definition at line 141 of file utilities.py.

        def diff_prettyText(self, diffs):
            """Convert a diff array into a pretty Text report.
            Args:
              diffs: Array of diff tuples.
            Returns:
              Text representation.
            """
            last_text = "\n"
            last_op_type = self.DIFF_EQUAL

            results_diff = []
            cut_next_new_line = [False]

            # print('\ndiffs:\n%s\n' % diffs)
            operations = (self.DIFF_INSERT, self.DIFF_DELETE)

            def parse(sign):
                # print('new1:', text.encode( 'ascii' ))

                if text:
                    new = text

                else:
                    return ''

                new = textwrap_indent( "%s" % new, sign, lambda line: True )

                # force the diff change to show up on a new line for highlighting
                if len(results_diff) > 0:
                    new = '\n' + new

                if new[-1] == '\n':

                    if op == self.DIFF_INSERT and next_text and new[-1] == '\n' and next_text[0] == '\n':
                        cut_next_new_line[0] = True;

                        # Avoids a double plus sign showing up when the diff has the element (1, '\n')
                        if len(text) > 1: new = new + '%s\n' % sign

                elif next_op not in operations and next_text and next_text[0] != '\n':
                    new = new + '\n'

                # print('new2:', new.encode( 'ascii' ))
                return new

            for index in range(len(diffs)):
                op, text = diffs[index]
                if index < len(diffs) - 1:
                    next_op, next_text = diffs[index+1]
                else:
                    next_op, next_text = (0, "")

                if op == self.DIFF_INSERT:
                    results_diff.append( parse( "+ " ) )

                elif op == self.DIFF_DELETE:
                    results_diff.append( parse( "- " ) )

                elif op == self.DIFF_EQUAL:
                    # print('new3:', text.encode( 'ascii' ))
                    # if last_op_type != op or last_text and last_text[-1] == '\n': text = textwrap_indent(text, "  ")
                    text = textwrap_indent(text, "  ")

                    if cut_next_new_line[0]:
                        cut_next_new_line[0] = False
                        text = text[1:]

                    results_diff.append(text)
                    # print('new4:', text.encode( 'ascii' ))

                last_text = text
                last_op_type = op

            return "".join(results_diff)

---

The documentation for this class was generated from the following file:

• utilities.py