for branch in cs.branches:

            desc_msg.append('branch: %s<br/>' % branch)

        for book in cs.bookmarks:

            desc_msg.append('bookmark: %s<br/>' % book)

        for tag in cs.tags:

            desc_msg.append('tag: %s<br/>' % tag)

        changes = []

        diff_limit = safe_int(kallithea.CONFIG.get('rss_cut_off_limit', 32 * 1024))

        raw_diff = cs.diff()

        diff_processor = DiffProcessor(raw_diff,

                                       diff_limit=diff_limit,

        for st in diff_processor.parsed:

            st.update({'added': st['stats']['added'],

                       'removed': st['stats']['deleted']})

            changes.append('\n %(operation)s %(filename)s '

                           '(%(added)s lines added, %(removed)s lines removed)'

                            % st)

        if diff_processor.limited_diff:

            changes = changes + ['\n ' +

                                 _('Changeset was too big and was cut off...')]

        # rev link

    a_path = filenode_old.path # default, might be overriden by actual rename in diff

    if filenode_old.is_binary or filenode_new.is_binary:

        html_diff = wrap_to_table(_('Binary file'))

        stats = (0, 0)

    elif diff_limit != -1 and (

            diff_limit is None or

            (filenode_old.size < diff_limit and filenode_new.size < diff_limit)):

        raw_diff = get_gitdiff(filenode_old, filenode_new,

                                ignore_whitespace=ignore_whitespace,

                                context=line_context)

        if diff_processor.parsed: # there should be exactly one element, for the specified file

            f = diff_processor.parsed[0]

            op = f['operation']

            a_path = f['old_filename']

        html_diff = as_html(parsed_lines=diff_processor.parsed)

        stats = diff_processor.stat()

    else:

        html_diff = wrap_to_table(_('Changeset was too big and was cut off, use '

                               'diff menu to display this diff'))

        stats = (0, 0)

DEL_FILENODE = 2

MOD_FILENODE = 3

RENAMED_FILENODE = 4

COPIED_FILENODE = 5

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

    """

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

        """

        :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, bytes):

            raise Exception('Diff must be bytes - got %s' % type(diff))

        self._diff = memoryview(diff)

        self.adds = 0

        self.removes = 0

        self.diff_limit = diff_limit

        self.limited_diff = False

        self.vcs = vcs

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

                  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,

            })

            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 = next(lineiter)

                    while True:

                        # find a first del line

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

                            peekline = next(lineiter)