elif method == 'patch':

            response.content_type = 'text/plain'

            c.diff = safe_unicode(diff)

            return render('changeset/patch_changeset.html')

        elif method == 'raw':

            response.content_type = 'text/plain'

            return diff

        elif method == 'show':

            self.__load_data()

            if len(c.cs_ranges) == 1:

                return render('changeset/changeset.html')

            else:

                return render('changeset/changeset_range.html')

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def index(self, revision, method='show'):

        return self._index(revision, method=method)

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def changeset_raw(self, revision):

                    category='warning')

            redirect(url('summary_home', repo_name=repo.repo_name))

        except RepositoryError, e:

            log.error(traceback.format_exc())

            h.flash(safe_str(e), category='warning')

            if not partial:

                redirect(h.url('summary_home', repo_name=repo.repo_name))

            raise HTTPBadRequest()

    def _get_changesets(self, alias, org_repo, org_rev, other_repo, other_rev):

        """

        :param org_repo: repo object, that is most likely the orginal repo we forked from

        :param org_rev: the revision we want our compare to be made

        :param other_repo: repo object, mostl likely the fork of org_repo. It hass

            all changesets that we need to obtain

        :param other_rev: revision we want out compare to be made on other_repo

        """

        ancestor = None

        if org_rev == other_rev:

            ancestor = org_rev

        elif alias == 'hg':

            #case two independent repos

            if org_repo != other_repo:

                hgrepo = unionrepo.unionrepository(other_repo.baseui,

                                                   other_repo.path,

                                                   org_repo.path)

            #no remote compare do it on the same repository

            else:

                hgrepo = other_repo._repo

            ancestors = hgrepo.revs("ancestor(id(%s), id(%s))", org_rev, other_rev)

            if ancestors:

                # pick arbitrary ancestor - but there is usually only one

                ancestor = hgrepo[ancestors[0]].hex()

        elif alias == 'git':

            if org_repo != other_repo:

                from dulwich.repo import Repo

                from dulwich.client import SubprocessGitClient

                gitrepo = Repo(org_repo.path)

                SubprocessGitClient(thin_packs=False).fetch(other_repo.path, gitrepo)

                gitrepo_remote = Repo(other_repo.path)

                SubprocessGitClient(thin_packs=False).fetch(org_repo.path, gitrepo_remote)

                revs = []

                for x in gitrepo_remote.get_walker(include=[other_rev],

                                                   exclude=[org_rev]):

                    revs.append(x.commit.id)

                else:

                    # no changesets from other repo, ancestor is the other_rev

                    ancestor = other_rev

            else:

                so, se = org_repo.run_git_command(

                    'log --reverse --pretty="format: %%H" -s %s..%s'

                        % (org_rev, other_rev)

                )

                              for cs in re.findall(r'[0-9a-fA-F]{40}', so)]

        else:

            raise Exception('Bad alias only git and hg is allowed')

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def index(self, repo_name):

        c.compare_home = True

        org_repo = c.db_repo.repo_name

        other_repo = request.GET.get('other_repo', org_repo)

        c.org_repo = Repository.get_by_repo_name(org_repo)

        c.other_repo = Repository.get_by_repo_name(other_repo)

        c.org_ref_name = c.other_ref_name = _('Select changeset')

        return render('compare/compare_diff.html')

        c.org_rev = self.__get_rev_or_redirect(ref=org_ref, repo=org_repo, partial=partial)

        c.other_rev = self.__get_rev_or_redirect(ref=other_ref, repo=other_repo, partial=partial)

        c.compare_home = False

        c.org_repo = org_repo

        c.other_repo = other_repo

        c.org_ref_name = org_ref_name

        c.other_ref_name = other_ref_name

        c.org_ref_type = org_ref_type

        c.other_ref_type = other_ref_type

            org_repo.scm_instance.alias, org_repo.scm_instance, c.org_rev,

            other_repo.scm_instance, c.other_rev)

        c.statuses = c.db_repo.statuses(

            [x.raw_id for x in c.cs_ranges])

        if partial:

            return render('compare/compare_cs.html')

        if merge and c.ancestor:

            # 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'

        """

        c.org_repo = pull_request.org_repo

        (c.org_ref_type,

         c.org_ref_name,

         c.org_rev) = pull_request.org_ref.split(':')

        c.other_repo = c.org_repo

        (c.other_ref_type,

         c.other_ref_name,

         c.other_rev) = pull_request.other_ref.split(':')

        c.cs_ranges = [c.org_repo.get_changeset(x) for x in pull_request.revisions]

        c.statuses = c.org_repo.statuses([x.raw_id for x in c.cs_ranges])

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

        diff_limit = self.cut_off_limit if not c.fulldiff else None

        # 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.other_rev, c.org_rev, c.org_repo.scm_instance.path))

        txtdiff = c.org_repo.scm_instance.get_diff(rev1=safe_str(c.other_rev), rev2=safe_str(c.org_rev))

        diff_processor = diffs.DiffProcessor(txtdiff or '', format='gitdiff',

        </tr>

    %endfor

    </table>

    %if c.ancestor:

      <div class="ancestor">${_('Ancestor')}:

        ${h.link_to(h.short_id(c.ancestor),h.url('changeset_home',repo_name=c.repo_name,revision=c.ancestor))}

      </div>

    %endif

    %if c.as_form:

      ${h.hidden('ancestor_rev',c.ancestor)}

      ${h.hidden('merge_rev',c.cs_ranges[-1].raw_id)}

    %endif

  %endif

</div>

<script>

$('.expand_commit').on('click',function(e){

    $(this).children('i').hide();

    var cid = $(this).attr('commit_id');

    $('#C-'+cid).css({'height': 'auto','width': 'auto', 'white-space': 'pre'})

});

$('.gravatar').on('click',function(e){

    var cid = $(this).attr('commit_id');

    $('#row-'+cid).toggleClass('hl', !$('#row-'+cid).hasClass('hl'));