^rename[ ]to[ ](?P<rename_to>.+)(?:\n|$))?

    (?:^copy[ ]from[ ](?P<copy_from>.+)\n

       ^copy[ ]to[ ](?P<copy_to>.+)(?:\n|$))?

    (?:^new[ ]file[ ]mode[ ](?P<new_file_mode>.+)(?:\n|$))?

    (?:^deleted[ ]file[ ]mode[ ](?P<deleted_file_mode>.+)(?:\n|$))?

    (?:^index[ ](?P<a_blob_id>[0-9A-Fa-f]+)

        \.\.(?P<b_blob_id>[0-9A-Fa-f]+)[ ]?(?P<b_mode>.+)?(?:\n|$))?

    (?:^(?P<bin_patch>GIT[ ]binary[ ]patch)(?:\n|$))?

    (?:^---[ ](a/(?P<a_file>.+?)|/dev/null)\t?(?:\n|$))?

    (?:^\+\+\+[ ](b/(?P<b_file>.+?)|/dev/null)\t?(?:\n|$))?

""", re.VERBOSE | re.MULTILINE)

_header_next_check = re.compile(br'''(?!@)(?!literal )(?!delta )''')

_git_bs_escape_re = re.compile(r'\\(?:([^0-9])|([0-9]{3}))')

_git_bs_escape_dict = {'\\': '\\', '"': '"', 'r': '\r', 'n': '\n', 't': '\t'}

def _git_bs_unescape_m(m):

    c = m.group(1)

    if c is not None:

        return _git_bs_escape_dict.get(c) or ('\\' + c)

    return chr(int(m.group(2), 8))

def _get_header(vcs, diff_chunk):

    """

    Parses a Git diff for a single file (header and chunks) and returns a tuple with:

    1. A dict with meta info:

        a_path, b_path, similarity_index, rename_from, rename_to,

        old_mode, new_mode, new_file_mode, deleted_file_mode,

        a_blob_id, b_blob_id, b_mode, a_file, b_file

    2. An iterator yielding lines with simple HTML markup.

    """

    match = None

    if vcs == 'git':

        match = _git_header_re.match(diff_chunk)

    elif vcs == 'hg':

        match = _hg_header_re.match(diff_chunk)

    if match is None:

        raise Exception('diff not recognized as valid %s diff: %r' % (vcs, safe_str(bytes(diff_chunk[:1000]))))

    meta_info = {k: None if v is None else safe_str(v) for k, v in match.groupdict().items()}

    if vcs == 'git':

        for k in ['a_path', 'b_path', 'a_file', 'b_file']:

            v = meta_info.get(k)

            if v:

                meta_info[k] = _git_bs_escape_re.sub(_git_bs_unescape_m, v)

    rest = diff_chunk[match.end():]

    if rest:

        if _header_next_check.match(rest):

            raise Exception('cannot parse %s diff header: %r followed by %r' % (vcs, safe_str(bytes(diff_chunk[:match.end()])), safe_str(bytes(rest[:1000]))))

        if rest[-1:] != b'\n':

            # The diff will generally already have trailing \n (and be a memoryview). It might also be huge so we don't want to allocate it twice. But in this very rare case, we don't care.

            rest = bytes(rest) + b'\n'

    diff_lines = (safe_str(m.group(1)) for m in re.finditer(br'(.*)\n', rest))

    return meta_info, diff_lines

_chunk_re = re.compile(r'^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)')

_newline_marker = re.compile(r'^\\ No newline at end of file')

def _parse_lines(diff_lines):

    """

    Given an iterator of diff body lines, parse them and return a dict per

    line and added/removed totals.

    """

    added = deleted = 0

    old_line = old_end = new_line = new_end = None

    chunks = []

    try:

        line = next(diff_lines)

        while True:

            lines = []

            chunks.append(lines)

            match = _chunk_re.match(line)

            if not match:

                raise Exception('error parsing diff @@ line %r' % line)

            gr = match.groups()

            (old_line, old_end,

             new_line, new_end) = [int(x or 1) for x in gr[:-1]]

            old_line -= 1

            new_line -= 1

            old_end += old_line

            new_end += new_line

            line = next(diff_lines)

            while old_line < old_end or new_line < new_end:

                if not line:

                    raise Exception('error parsing diff - empty line at -%s+%s' % (old_line, new_line))

                affects_old = affects_new = False

                command = line[0]

                if command == '+':

                    affects_new = True

                    action = 'add'

                    added += 1

                elif command == '-':

                    affects_old = True

                    action = 'del'

                    deleted += 1

                elif command == ' ':

                    affects_old = affects_new = True

                    action = 'unmod'

                else:

                    raise Exception('error parsing diff - unknown command in line %r at -%s+%s' % (line, old_line, new_line))

                if not _newline_marker.match(line):

                    old_line += affects_old

                    new_line += affects_new

                    lines.append({

                        'old_lineno':   affects_old and old_line or '',

                        'new_lineno':   affects_new and new_line or '',

                        'action':       action,

                        'line':         line[1:],

                    })

                line = next(diff_lines)

                if _newline_marker.match(line):

                    # we need to append to lines, since this is not

                    # counted in the line specs of diff

                    lines.append({

                        'old_lineno':   '',

                        'new_lineno':   '',

                        'action':       'context',

                        'line':         line,

                    })

                    line = next(diff_lines)

            if old_line > old_end:

                raise Exception('error parsing diff - more than %s "-" lines at -%s+%s' % (old_end, old_line, new_line))

            if new_line > new_end:

                raise Exception('error parsing diff - more than %s "+" lines at -%s+%s' % (new_end, old_line, new_line))

    except StopIteration:

        pass

    if old_line != old_end or new_line != new_end:

        raise Exception('diff processing broken when old %s<>%s or new %s<>%s line %r' % (old_line, old_end, new_line, new_end, line))

    return chunks, added, deleted

# Used for inline highlighter word split, must match the substitutions in _escaper

_token_re = re.compile(r'()(&amp;|&lt;|&gt;|<u>\t</u>|<u class="cr"></u>| <i></i>|\W+?)')

def _highlight_inline_diff(old, new):

    """

    Highlight simple add/remove in two lines given as info dicts. They are

    modified in place and given markup with <del>/<ins>.

    """

    assert old['action'] == 'del'

    assert new['action'] == 'add'

    oldwords = _token_re.split(old['line'])

    newwords = _token_re.split(new['line'])

    sequence = difflib.SequenceMatcher(None, oldwords, newwords)

    oldfragments, newfragments = [], []

    for tag, i1, i2, j1, j2 in sequence.get_opcodes():

        oldfrag = ''.join(oldwords[i1:i2])

        newfrag = ''.join(newwords[j1:j2])

        if tag != 'equal':

            if oldfrag:

                oldfrag = '<del>%s</del>' % oldfrag

            if newfrag:

                newfrag = '<ins>%s</ins>' % newfrag

        oldfragments.append(oldfrag)

        newfragments.append(newfrag)

    old['line'] = "".join(oldfragments)

    new['line'] = "".join(newfragments)