raise RepositoryError('Changeset range returned empty result')

        except (ChangesetDoesNotExistError, EmptyRepositoryError):

            log.debug(traceback.format_exc())

            msg = _('Such revision does not exist for this repository')

            h.flash(msg, category='error')

            raise HTTPNotFound()

        c.changes = OrderedDict()

        c.lines_added = 0  # count of lines added

        c.lines_deleted = 0  # count of lines removes

        c.changeset_statuses = ChangesetStatus.STATUSES

        comments = dict()

        c.statuses = []

        c.inline_comments = []

        c.inline_cnt = 0

        # Iterate over ranges (default changeset view is always one changeset)

        for changeset in c.cs_ranges:

            if method == 'show':

                c.statuses.extend([ChangesetStatusModel().get_status(

                            c.db_repo.repo_id, changeset.raw_id)])

                # Changeset comments

                comments.update((com.comment_id, com)

                                for com in ChangesetCommentsModel()

                                .get_comments(c.db_repo.repo_id,

                                              revision=changeset.raw_id))

                # Status change comments - mostly from pull requests

                comments.update((st.comment_id, st.comment)

                                for st in ChangesetStatusModel()

                                .get_statuses(c.db_repo.repo_id,

                                              changeset.raw_id, with_revisions=True)

                                if st.comment_id is not None)

                inlines = ChangesetCommentsModel() \

                            .get_inline_comments(c.db_repo.repo_id,

                                                 revision=changeset.raw_id)

                c.inline_comments.extend(inlines)

            cs2 = changeset.raw_id

            cs1 = changeset.parents[0].raw_id if changeset.parents else EmptyChangeset().raw_id

            context_lcl = get_line_ctx('', request.GET)

            ign_whitespace_lcl = get_ignore_ws('', request.GET)

                ignore_whitespace=ign_whitespace_lcl, context=context_lcl)

            diff_limit = None if c.fulldiff else self.cut_off_limit

            file_diff_data = []

            if method == 'show':

                diff_processor = diffs.DiffProcessor(raw_diff,

                                                     vcs=c.db_repo_scm_instance.alias,

                                                     diff_limit=diff_limit)

                c.limited_diff = diff_processor.limited_diff

                for f in diff_processor.parsed:

                    st = f['stats']

                    c.lines_added += st['added']

                    c.lines_deleted += st['deleted']

                    filename = f['filename']

                    fid = h.FID(changeset.raw_id, filename)

                    url_fid = h.FID('', filename)

                    html_diff = diffs.as_html(enable_comments=enable_comments, parsed_lines=[f])

                    file_diff_data.append((fid, url_fid, f['operation'], f['old_filename'], filename, html_diff, st))

            else:

                # downloads/raw we only need RAW diff nothing else

                file_diff_data.append(('', None, None, None, raw_diff, None))

            c.changes[changeset.raw_id] = (cs1, cs2, file_diff_data)

        # sort comments in creation order

        c.comments = [com for com_id, com in sorted(comments.items())]

        # count inline comments

        for __, lines in c.inline_comments:

            for comments in lines.values():

                c.inline_cnt += len(comments)

        if len(c.cs_ranges) == 1:

            c.changeset = c.cs_ranges[0]

            c.parent_tmpl = ''.join(['# Parent  %s\n' % x.raw_id

                                     for x in c.changeset.parents])

        if method == 'download':

            response.content_type = 'text/plain'

            response.content_disposition = 'attachment; filename=%s.diff' \

                                            % revision[:12]

            return raw_diff

        elif method == 'patch':

            response.content_type = 'text/plain'

            c.diff = safe_unicode(raw_diff)

            return render('changeset/patch_changeset.html')

        elif method == 'raw':

            response.content_type = 'text/plain'

            return raw_diff

        elif method == 'show':

            self.__load_data()

            c.a_repo.scm_instance.alias, c.a_repo.scm_instance, c.a_rev,

            c.cs_repo.scm_instance, c.cs_rev)

        raw_ids = [x.raw_id for x in c.cs_ranges]

        c.cs_comments = c.cs_repo.get_comments(raw_ids)

        c.cs_statuses = c.cs_repo.statuses(raw_ids)

        revs = [ctx.revision for ctx in reversed(c.cs_ranges)]

        c.jsdata = graph_data(c.cs_repo.scm_instance, revs)

        if partial:

            return render('compare/compare_cs.html')

        org_repo = c.a_repo

        other_repo = c.cs_repo

        if merge:

            rev1 = msg = None

            if not c.cs_ranges:

                msg = _('Cannot show empty diff')

            elif not c.ancestors:

                msg = _('No ancestor found for merge diff')

            elif len(c.ancestors) == 1:

                rev1 = c.ancestors[0]

            else:

                msg = _('Multiple merge ancestors found for merge compare')

            if rev1 is None:

                h.flash(msg, category='error')

                log.error(msg)

                raise HTTPNotFound

            # case we want a simple diff without incoming changesets,

            # previewing what will be merged.

            # Make the diff on the other repo (which is known to have other_rev)

            log.debug('Using ancestor %s as rev1 instead of %s',

                      rev1, c.a_rev)

            org_repo = other_repo

        else: # comparing tips, not necessarily linearly related

            if org_repo != other_repo:

                # TODO: we could do this by using hg unionrepo

                log.error('cannot compare across repos %s and %s', org_repo, other_repo)

                h.flash(_('Cannot compare repositories without using common ancestor'), category='error')

                raise HTTPBadRequest

            rev1 = c.a_rev

        diff_limit = None if fulldiff else self.cut_off_limit

        log.debug('running diff between %s and %s in %s',

                  rev1, c.cs_rev, org_repo.scm_instance.path)

                                      ignore_whitespace=ignore_whitespace,

                                      context=line_context)

        diff_processor = diffs.DiffProcessor(raw_diff or '', diff_limit=diff_limit)

        c.limited_diff = diff_processor.limited_diff

        c.file_diff_data = []

        c.lines_added = 0

        c.lines_deleted = 0

        for f in diff_processor.parsed:

            st = f['stats']

            c.lines_added += st['added']

            c.lines_deleted += st['deleted']

            filename = f['filename']

            fid = h.FID('', filename)

            html_diff = diffs.as_html(enable_comments=False, parsed_lines=[f])

            c.file_diff_data.append((fid, None, f['operation'], f['old_filename'], filename, html_diff, st))

        return render('compare/compare_diff.html')

                                                               org_scm_instance.path,

                                                               other_scm_instance.path)

                        else:

                            hgrepo = org_scm_instance._repo

                        show = set(hgrepo.revs('::%ld & !::parents(%s) & !::%s',

                                               avail_revs, revs[0], targethead))

                        c.update_msg = _('The following additional changes are available on %s:') % c.cs_branch_name

                    else:

                        show = set()

                        avail_revs = set() # drop revs[0]

                        c.update_msg = _('No additional changesets found for iterating on this pull request.')

                    # TODO: handle branch heads that not are tip-most

                    brevs = org_scm_instance._repo.revs('%s - %ld - %s', c.cs_branch_name, avail_revs, revs[0])

                    if brevs:

                        # also show changesets that are on branch but neither ancestors nor descendants

                        show.update(org_scm_instance._repo.revs('::%ld - ::%ld - ::%s', brevs, avail_revs, c.a_branch_name))

                        show.add(revs[0]) # make sure graph shows this so we can see how they relate

                        c.update_msg_other = _('Note: Branch %s has another head: %s.') % (c.cs_branch_name,

                            h.short_id(org_scm_instance.get_changeset((max(brevs))).raw_id))

                    avail_show = sorted(show, reverse=True)

            elif org_scm_instance.alias == 'git':

                c.cs_repo.scm_instance.get_changeset(c.cs_rev) # check it exists - raise ChangesetDoesNotExistError if not

                c.update_msg = _("Git pull requests don't support iterating yet.")

        except ChangesetDoesNotExistError:

            c.update_msg = _('Error: some changesets not found when displaying pull request from %s.') % c.cs_rev

        c.avail_revs = avail_revs

        c.avail_cs = [org_scm_instance.get_changeset(r) for r in avail_show]

        c.avail_jsdata = graph_data(org_scm_instance, avail_show)

        raw_ids = [x.raw_id for x in c.cs_ranges]

        c.cs_comments = c.cs_repo.get_comments(raw_ids)

        c.cs_statuses = c.cs_repo.statuses(raw_ids)

        ignore_whitespace = request.GET.get('ignorews') == '1'

        line_context = safe_int(request.GET.get('context'), 3)

        c.ignorews_url = _ignorews_url

        c.context_url = _context_url

        fulldiff = request.GET.get('fulldiff')

        diff_limit = None if fulldiff else self.cut_off_limit

        # we swap org/other ref since we run a simple diff on one repo

        log.debug('running diff between %s and %s in %s',

                  c.a_rev, c.cs_rev, org_scm_instance.path)

        try:

        except ChangesetDoesNotExistError:

            raw_diff = _("The diff can't be shown - the PR revisions could not be found.")

        diff_processor = diffs.DiffProcessor(raw_diff or '', diff_limit=diff_limit)

        c.limited_diff = diff_processor.limited_diff

        c.file_diff_data = []

        c.lines_added = 0

        c.lines_deleted = 0

        for f in diff_processor.parsed:

            st = f['stats']

            c.lines_added += st['added']

            c.lines_deleted += st['deleted']

            filename = f['filename']

            fid = h.FID('', filename)

            html_diff = diffs.as_html(enable_comments=True, parsed_lines=[f])

            c.file_diff_data.append((fid, None, f['operation'], f['old_filename'], filename, html_diff, st))

        # inline comments

        c.inline_cnt = 0

        c.inline_comments = cc_model.get_inline_comments(

                                c.db_repo.repo_id,

                                pull_request=pull_request_id)

        # count inline comments

        for __, lines in c.inline_comments:

            for comments in lines.values():

                c.inline_cnt += len(comments)

        # comments

        c.comments = cc_model.get_comments(c.db_repo.repo_id, pull_request=pull_request_id)

        # (badly named) pull-request status calculation based on reviewer votes

        (c.pull_request_reviewers,

         c.pull_request_pending_reviewers,

         c.current_voting_result,

         ) = cs_model.calculate_pull_request_result(c.pull_request)

        c.changeset_statuses = ChangesetStatus.STATUSES

        c.is_ajax_preview = False

        c.ancestors = None # [c.a_rev] ... but that is shown in an other way

        return render('/pullrequests/pullrequest_show.html')

    @LoginRequired()

    @NotAnonymous()

    @HasRepoPermissionLevelDecorator('read')

    @jsonify

    def comment(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        status = request.POST.get('changeset_status')

        diff_processor = DiffProcessor(raw_diff)

        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, enable_comments=enable_comments)

        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)

    if not html_diff:

        submodules = filter(lambda o: isinstance(o, SubModuleNode),

                            [filenode_new, filenode_old])

        if submodules:

            html_diff = wrap_to_table(escape('Submodule %r' % submodules[0]))

        else:

            html_diff = wrap_to_table(_('No changes detected'))

    cs1 = filenode_old.changeset.raw_id

    cs2 = filenode_new.changeset.raw_id

    return cs1, cs2, a_path, html_diff, stats, op

def get_gitdiff(filenode_old, filenode_new, ignore_whitespace=True, context=3):

    """

    Returns git style diff between given ``filenode_old`` and ``filenode_new``.

    """

    # make sure we pass in default context

    context = context or 3

    submodules = filter(lambda o: isinstance(o, SubModuleNode),

                        [filenode_new, filenode_old])

    if submodules:

        return ''

    for filenode in (filenode_old, filenode_new):

        if not isinstance(filenode, FileNode):

            raise VCSError("Given object should be FileNode object, not %s"

                % filenode.__class__)

    repo = filenode_new.changeset.repository

    old_raw_id = getattr(filenode_old.changeset, 'raw_id', repo.EMPTY_CHANGESET)

    new_raw_id = getattr(filenode_new.changeset, 'raw_id', repo.EMPTY_CHANGESET)

    return vcs_gitdiff

NEW_FILENODE = 1

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

    can be used to render it in a HTML template.

    """

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

    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 _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: