tag,

                    l['line'][last:]

                )

            do(line)

            do(next_)

    def _get_header(self, diff_chunk):

        """

        parses the diff header, and returns parts, and leftover diff

        parts consists of 14 elements::

            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

        :param diff_chunk:

        :type diff_chunk:

        """

        if self.vcs == 'git':

            match = self._git_header_re.match(diff_chunk)

            diff = diff_chunk[match.end():]

            return match.groupdict(), imap(self._escaper, diff.splitlines(1))

        elif self.vcs == 'hg':

            match = self._hg_header_re.match(diff_chunk)

            diff = diff_chunk[match.end():]

            return match.groupdict(), imap(self._escaper, diff.splitlines(1))

        else:

            raise Exception('VCS type %s is not supported' % self.vcs)

    def _clean_line(self, line, command):

        if command in ['+', '-', ' ']:

            #only modify the line if it's actually a diff thing

            line = line[1:]

        return line

    def _parse_gitdiff(self, inline_diff=True):

        _files = []

        diff_container = lambda arg: arg

        ##split the diff in chunks of separate --git a/file b/file chunks

        for raw_diff in ('\n' + self._diff).split('\ndiff --git')[1:]:

            head, diff = self._get_header(raw_diff)

            op = None

            stats = None

            msgs = []

                if head['deleted_file_mode']:

                    op = 'D'

                    stats = ['b', DEL_FILENODE]

                    msgs.append('deleted file')

                elif head['new_file_mode']:

                    op = 'A'

                    stats = ['b', NEW_FILENODE]

                    msgs.append('new file %s' % head['new_file_mode'])

                else:

                    if head['new_mode'] and head['old_mode']:

                        op = 'M'

                        stats = ['b', CHMOD_FILENODE]

                        msgs.append('modified file chmod %s => %s'

                                      % (head['old_mode'], head['new_mode']))

                    if (head['rename_from'] and head['rename_to']

                          and head['rename_from'] != head['rename_to']):

                        op = 'M'

                        stats = ['b', RENAMED_FILENODE] # might overwrite CHMOD_FILENODE

                        msgs.append('file renamed from %s to %s'

                                      % (head['rename_from'], head['rename_to']))

                    if op is None:

                        op = 'M'

                        stats = ['b', MOD_FILENODE]

            if head['a_file'] or head['b_file']: # a real diff

                try:

                    chunks, stats = self._parse_lines(diff)

                except DiffLimitExceeded:

                    diff_container = lambda _diff: LimitedDiffContainer(

                                                self.diff_limit,

                                                self.cur_diff_size,

                                                _diff)

                    break

            else: # GIT binary patch (or empty diff)

                chunks = []

                msgs.append('binary diff not shown') # or no diff because it was a rename or chmod or add/remove of empty file

            if msgs:

                chunks.insert(0, [{

                    'old_lineno': '',

                    'new_lineno': '',

                    'action':     'binary',

                    'line':       msg,

                    } for msg in msgs])

            _files.append({

                'filename':         head['b_path'],

                'old_revision':     head['a_blob_id'],

                'new_revision':     head['b_blob_id'],

                'chunks':           chunks,

                'operation':        op,

                'stats':            stats,

            })

        sorter = lambda info: {'A': 0, 'M': 1, 'D': 2}.get(info['operation'])

        if not inline_diff:

            return diff_container(sorted(_files, key=sorter))

        # highlight inline changes

        for diff_data in _files:

            for chunk in diff_data['chunks']:

                lineiter = iter(chunk)

                try:

                    while 1:

                        line = lineiter.next()

                        if line['action'] not in ['unmod', 'context']:

                            nextline = lineiter.next()