CHMOD_FILENODE = 6

BIN_FILENODE = 7

class DiffProcessor(object):

    """

    Give it a unified or git diff and it returns a list of the files that were

    mentioned in the diff together with a dict of meta information that

    can be used to render it in a HTML template.

    """

    _diff_git_re = re.compile('^diff --git', re.MULTILINE)

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

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

    _git_header_re = re.compile(r"""

        ^diff[ ]--git

            [ ]a/(?P<a_path>.+?)[ ]b/(?P<b_path>.+?)\n

        (?:^old[ ]mode[ ](?P<old_mode>\d+)\n

           ^new[ ]mode[ ](?P<new_mode>\d+)(?:\n|$))?

        (?:^similarity[ ]index[ ](?P<similarity_index>\d+)%\n

           ^rename[ ]from[ ](?P<rename_from>.+)\n

           ^rename[ ]to[ ](?P<rename_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)

    _hg_header_re = re.compile(r"""

        ^diff[ ]--git

            [ ]a/(?P<a_path>.+?)[ ]b/(?P<b_path>.+?)\n

        (?:^old[ ]mode[ ](?P<old_mode>\d+)\n

           ^new[ ]mode[ ](?P<new_mode>\d+)(?:\n|$))?

        (?:^similarity[ ]index[ ](?P<similarity_index>\d+)%(?:\n|$))?

        (?:^rename[ ]from[ ](?P<rename_from>.+)\n

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

    _escape_re = re.compile(r'(&)|(<)|(>)|(\t)|(\r)|(?<=.)( \n| $)')

    def __init__(self, diff, vcs='hg', diff_limit=None, inline_diff=True):

        """

        :param diff:   a text in diff format

        :param vcs: type of version control hg or git

        :param diff_limit: define the size of diff that is considered "big"

            based on that parameter cut off will be triggered, set to None

            to show full diff

        """

        if not isinstance(diff, basestring):

            raise Exception('Diff must be a basestring got %s instead' % type(diff))

        self._diff = diff

        self.adds = 0

        self.removes = 0

        self.diff_limit = diff_limit

        self.limited_diff = False

        self.vcs = vcs

        self.parsed = self._parse_gitdiff(inline_diff=inline_diff)

    def _escaper(self, string):

        """

        Do HTML escaping/markup

        """

        def substitute(m):

            groups = m.groups()

            if groups[0]:

                return '&'

            if groups[1]:

                return '<'

            if groups[2]:

                return '>'

            if groups[3]:

                return '<u>\t</u>'

            if groups[4]:

                return '<u class="cr"></u>'

            if groups[5]:

                return ' <i></i>'

            assert False

        return self._escape_re.sub(substitute, safe_unicode(string))

    def _get_header(self, 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 self.vcs == 'git':

            match = self._git_header_re.match(diff_chunk)

        elif self.vcs == 'hg':

            match = self._hg_header_re.match(diff_chunk)

        if match is None:

            raise Exception('diff not recognized as valid %s diff' % self.vcs)

        meta_info = match.groupdict()

        rest = diff_chunk[match.end():]

        if rest and not rest.startswith('@') and not rest.startswith('literal ') and not rest.startswith('delta '):

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

        diff_lines = (self._escaper(m.group(0)) for m in re.finditer(r'.*\n|.+$', rest)) # don't split on \r as str.splitlines do

        return meta_info, diff_lines

    def _parse_gitdiff(self, inline_diff):

        """Parse self._diff and return a list of dicts with meta info and chunks for each file.

        Might set limited_diff.

        Optionally, do an extra pass and to extra markup of one-liner changes.

        """

        _files = [] # list of dicts with meta info and chunks

        starts = [m.start() for m in self._diff_git_re.finditer(self._diff)]

        starts.append(len(self._diff))

        for start, end in zip(starts, starts[1:]):

            if self.diff_limit and end > self.diff_limit:

                self.limited_diff = True

                continue

            head, diff_lines = self._get_header(buffer(self._diff, start, end - start))

            op = None

            stats = {

                'added': 0,

                'deleted': 0,

                'binary': False,

                # a way of seeing deleted content could perhaps be nice - but

                # not with the current UI

                chunks = []

            chunks.insert(0, [{

                'old_lineno': '',

                'new_lineno': '',

                'action':     'context',

                'line':       msg,

                } for _op, msg in stats['ops'].iteritems()

                  if _op not in [MOD_FILENODE]])

            _files.append({

                'old_filename':     head['a_path'],

                'filename':         head['b_path'],

                'old_revision':     head['a_blob_id'],

                'new_revision':     head['b_blob_id'],

                'chunks':           chunks,

                'operation':        op,

                'stats':            stats,

            })

        if not inline_diff:

            return _files

        # highlight inline changes when one del is followed by one add

        for diff_data in _files:

            for chunk in diff_data['chunks']:

                lineiter = iter(chunk)

                try:

                    peekline = lineiter.next()

                    while True:

                        # find a first del line

                        while peekline['action'] != 'del':

                            peekline = lineiter.next()

                        delline = peekline

                        peekline = lineiter.next()

                        # if not followed by add, eat all following del lines

                        if peekline['action'] != 'add':

                            while peekline['action'] == 'del':

                                peekline = lineiter.next()

                            continue

                        # found an add - make sure it is the only one

                        addline = peekline

                        try:

                            peekline = lineiter.next()

                        except StopIteration:

                            # add was last line - ok

                            raise

                        if peekline['action'] != 'add':

                            # there was only one add line - ok

                except StopIteration:

                    pass

        return _files

    def _parse_lines(self, 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

        try:

            chunks = []

            line = diff_lines.next()

            while True:

                lines = []

                chunks.append(lines)

                match = self._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

                context = len(gr) == 5

                old_end += old_line

                new_end += new_line

                if context:

                    # skip context only if it's first line

                    if int(gr[0]) > 1:

                        lines.append({

                            'old_lineno': '...',

                            'new_lineno': '...',

                            'action':     'context',

                            'line':       line,

                        })

                line = diff_lines.next()

                    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 self._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 = diff_lines.next()

                    if self._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 = diff_lines.next()

                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

    def stat(self):

        """

        Returns tuple of added, and removed lines for this instance

        """

        return self.adds, self.removes