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.changeset_comment_id, st.comment)

                                for st in ChangesetStatusModel()

                                .get_statuses(c.db_repo.repo_id,

                                              changeset.raw_id, with_revisions=True)

                                if st.changeset_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)

            _diff = c.db_repo_scm_instance.get_diff(cs1, cs2,

                ignore_whitespace=ign_whitespace_lcl, context=context_lcl)

            diff_limit = self.cut_off_limit if not fulldiff else None

            diff_processor = diffs.DiffProcessor(_diff,

                                                 vcs=c.db_repo_scm_instance.alias,

                                                 format='gitdiff',

                                                 diff_limit=diff_limit)

            file_diff_data = OrderedDict()

            if method == 'show':

                _parsed = diff_processor.prepare()

                c.limited_diff = False

                if isinstance(_parsed, LimitedDiffContainer):

                    c.limited_diff = True

                for f in _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)

                    diff = diff_processor.as_html(enable_comments=enable_comments,

                                                  parsed_lines=[f])

            else:

                # downloads/raw we only need RAW diff nothing else

                diff = diff_processor.as_raw()

                file_diff_data[''] = (None, None, None, 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 diff

        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:

                c.cs_ranges_org = None

                c.cs_comments = {}

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

                c.jsdata = json.dumps(graph_data(c.db_repo_scm_instance, revs))

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

        org_repo = c.a_repo

        other_repo = c.cs_repo

        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.ancestor, c.a_rev)

            rev1 = c.ancestor

            org_repo = other_repo

        else: # comparing tips, not necessarily linearly related

            if merge:

                log.error('Unable to find ancestor revision')

            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 = self.cut_off_limit if not c.fulldiff else None

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

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

        txtdiff = org_repo.scm_instance.get_diff(rev1=rev1, rev2=c.cs_rev,

                                      ignore_whitespace=ignore_whitespace,

                                      context=line_context)

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

                                             diff_limit=diff_limit)

        _parsed = diff_processor.prepare()

        c.limited_diff = False

        if isinstance(_parsed, LimitedDiffContainer):

            c.limited_diff = True

        c.file_diff_data = OrderedDict()

        c.lines_added = 0

        c.lines_deleted = 0

        for f in _parsed:

            st = f['stats']

            c.lines_added += st['added']

            c.lines_deleted += st['deleted']

            filename = f['filename']

            fid = h.FID('', filename)

            diff = diff_processor.as_html(enable_comments=False,

                                          parsed_lines=[f])

        return render('compare/compare_diff.html')

            if diff2 not in ['', None, 'None', '0' * 12, '0' * 40]:

                c.changeset_2 = c.db_repo_scm_instance.get_changeset(diff2)

                try:

                    node2 = c.changeset_2.get_node(f_path)

                    if node2.is_dir():

                        raise NodeError('%s path is a %s not a file'

                                        % (node2, type(node2)))

                except NodeDoesNotExistError:

                    c.changeset_2 = EmptyChangeset(cs=diff2,

                                                   revision=c.changeset_2.revision,

                                                   repo=c.db_repo_scm_instance)

                    node2 = FileNode(f_path, '', changeset=c.changeset_2)

            else:

                c.changeset_2 = EmptyChangeset(repo=c.db_repo_scm_instance)

                node2 = FileNode(f_path, '', changeset=c.changeset_2)

        except (RepositoryError, NodeError):

            log.error(traceback.format_exc())

            raise HTTPFound(location=url('files_home', repo_name=c.repo_name,

                                f_path=f_path))

        if c.action == 'download':

            _diff = diffs.get_gitdiff(node1, node2,

                                      ignore_whitespace=ignore_whitespace,

                                      context=line_context)

            diff = diffs.DiffProcessor(_diff, format='gitdiff')

            diff_name = '%s_vs_%s.diff' % (diff1, diff2)

            response.content_type = 'text/plain'

            response.content_disposition = (

                'attachment; filename=%s' % diff_name

            )

            return diff.as_raw()

        elif c.action == 'raw':

            _diff = diffs.get_gitdiff(node1, node2,

                                      ignore_whitespace=ignore_whitespace,

                                      context=line_context)

            diff = diffs.DiffProcessor(_diff, format='gitdiff')

            response.content_type = 'text/plain'

            return diff.as_raw()

        else:

            fid = h.FID(diff2, node2.path)

            line_context_lcl = get_line_ctx(fid, request.GET)

            ign_whitespace_lcl = get_ignore_ws(fid, request.GET)

            lim = request.GET.get('fulldiff') or self.cut_off_limit

                                         filenode_new=node2,

                                         cut_off_limit=lim,

                                         ignore_whitespace=ign_whitespace_lcl,

                                         line_context=line_context_lcl,

                                         enable_comments=False)

            return render('files/file_diff.html')

    @LoginRequired()

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

                                   'repository.admin')

    def diff_2way(self, repo_name, f_path):

        diff1 = request.GET.get('diff1', '')

        diff2 = request.GET.get('diff2', '')

        try:

            if diff1 not in ['', None, 'None', '0' * 12, '0' * 40]:

                c.changeset_1 = c.db_repo_scm_instance.get_changeset(diff1)

                try:

                    node1 = c.changeset_1.get_node(f_path)

                    if node1.is_dir():

                        raise NodeError('%s path is a %s not a file'

                                        % (node1, type(node1)))

                except NodeDoesNotExistError:

                    c.changeset_1 = EmptyChangeset(cs=diff1,

                                                   revision=c.changeset_1.revision,

                                                   repo=c.db_repo_scm_instance)

                    node1 = FileNode(f_path, '', changeset=c.changeset_1)

            else:

                c.changeset_1 = EmptyChangeset(repo=c.db_repo_scm_instance)

                node1 = FileNode(f_path, '', changeset=c.changeset_1)

            if diff2 not in ['', None, 'None', '0' * 12, '0' * 40]:

                c.changeset_2 = c.db_repo_scm_instance.get_changeset(diff2)

                try:

                    node2 = c.changeset_2.get_node(f_path)

                    if node2.is_dir():

                        raise NodeError('%s path is a %s not a file'

                                        % (node2, type(node2)))

                except NodeDoesNotExistError:

                    c.changeset_2 = EmptyChangeset(cs=diff2,

                                                   revision=c.changeset_2.revision,

                                                   repo=c.db_repo_scm_instance)

                    node2 = FileNode(f_path, '', changeset=c.changeset_2)

            else:

                c.changeset_2 = EmptyChangeset(repo=c.db_repo_scm_instance)

                node2 = FileNode(f_path, '', changeset=c.changeset_2)

        except ChangesetDoesNotExistError as e:

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

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

            raise HTTPNotFound()

        c.node1 = node1

        c.node2 = node2

        c.cs1 = c.changeset_1

                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 = json.dumps(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.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

        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.a_rev, c.cs_rev, org_scm_instance.path)

        try:

            txtdiff = org_scm_instance.get_diff(rev1=safe_str(c.a_rev), rev2=safe_str(c.cs_rev),

                                                ignore_whitespace=ignore_whitespace,

                                                context=line_context)

        except ChangesetDoesNotExistError:

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

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

                                             diff_limit=diff_limit)

        _parsed = diff_processor.prepare()

        c.limited_diff = False

        if isinstance(_parsed, LimitedDiffContainer):

            c.limited_diff = True

        c.file_diff_data = OrderedDict()

        c.lines_added = 0

        c.lines_deleted = 0

        for f in _parsed:

            st = f['stats']

            c.lines_added += st['added']

            c.lines_deleted += st['deleted']

            filename = f['filename']

            fid = h.FID('', filename)

            diff = diff_processor.as_html(enable_comments=True,

                                          parsed_lines=[f])

        # 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.as_form = False

        c.ancestor = None # there is one - but right here we don't know which

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

    @LoginRequired()

    @NotAnonymous()

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

                                   'repository.admin')

    @jsonify

    def comment(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

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

        close_pr = request.POST.get('save_close')

        delete = request.POST.get('save_delete')

        f_path = request.POST.get('f_path')

        line_no = request.POST.get('line')

        if (status or close_pr or delete) and (f_path or line_no):

            # status votes and closing is only possible in general comments

            raise HTTPBadRequest()

        allowed_to_change_status = self._get_is_allowed_change_status(pull_request)

        if not allowed_to_change_status:

            if status or close_pr:

                h.flash(_('No permission to change pull request status'), 'error')

                raise HTTPForbidden()

Set of diffing helpers, previously part of vcs

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Dec 4, 2011

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import re

import difflib

import logging

from itertools import tee, imap

from pylons.i18n.translation import _

from kallithea.lib.vcs.exceptions import VCSError

from kallithea.lib.vcs.nodes import FileNode, SubModuleNode

from kallithea.lib.vcs.backends.base import EmptyChangeset

from kallithea.lib.helpers import escape

from kallithea.lib.utils2 import safe_unicode

log = logging.getLogger(__name__)

def wrap_to_table(str_):

    return '''<table class="code-difftable">

                <tr class="line no-comment">

                <td class="lineno new"></td>

                <td class="code no-comment"><pre>%s</pre></td>

                </tr>

              </table>''' % str_

def wrapped_diff(filenode_old, filenode_new, cut_off_limit=None,

                ignore_whitespace=True, line_context=3,

                enable_comments=False):

    """

    returns a wrapped diff into a table, checks for cut_off_limit and presents

    proper message

    """

    if filenode_old is None:

        filenode_old = FileNode(filenode_new.path, '', EmptyChangeset())

    op = None

    if filenode_old.is_binary or filenode_new.is_binary:

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

        stats = (0, 0)

    elif cut_off_limit != -1 and (

            cut_off_limit is None or

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

        f_gitdiff = get_gitdiff(filenode_old, filenode_new,

                                ignore_whitespace=ignore_whitespace,

                                context=line_context)

        diff_processor = DiffProcessor(f_gitdiff, format='gitdiff')

        _parsed = diff_processor.prepare()

        if _parsed: # there should be exactly one element, for the specified file

            f = _parsed[0]

            op = f['operation']

        diff = diff_processor.as_html(enable_comments=enable_comments)

        stats = diff_processor.stat()

    else:

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

                               'diff menu to display this diff'))

        stats = (0, 0)

    if not diff:

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

                            [filenode_new, filenode_old])

        if submodules:

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

        else:

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

    cs1 = filenode_old.changeset.raw_id

    cs2 = filenode_new.changeset.raw_id

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

    """

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

    :param ignore_whitespace: ignore whitespaces in diff

    """

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

    vcs_gitdiff = repo.get_diff(old_raw_id, new_raw_id, filenode_new.path,

                                ignore_whitespace, context)

    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 DiffLimitExceeded(Exception):

    pass

class LimitedDiffContainer(object):

    def __init__(self, diff_limit, cur_diff_size, diff):

        self.diff = diff

        self.diff_limit = diff_limit

        self.cur_diff_size = cur_diff_size

                    elif head['a_file'] and not head['b_file']:

                        op = 'D'

                        stats['binary'] = True

                        stats['ops'][DEL_FILENODE] = 'deleted file'

                # it's not ADD not DELETE

                if op is None:

                    op = 'M'

                    stats['binary'] = True

                    stats['ops'][MOD_FILENODE] = 'modified file'

            # a real non-binary diff

            if head['a_file'] or head['b_file']:

                try:

                    chunks, _stats = self._parse_lines(diff)

                    stats['binary'] = False

                    stats['added'] = _stats[0]

                    stats['deleted'] = _stats[1]

                    # explicit mark that it's a modified file

                    if op == 'M':

                        stats['ops'][MOD_FILENODE] = 'modified file'

                except DiffLimitExceeded:

                    diff_container = lambda _diff: \

                        LimitedDiffContainer(self.diff_limit,

                                            self.cur_diff_size, _diff)

                    break

            else:  # Git binary patch (or empty diff)

                # Git binary patch

                if head['bin_patch']:

                    stats['ops'][BIN_FILENODE] = 'binary diff not shown'

                chunks = []

            if op == 'D' and chunks:

                # 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({

                '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 diff_container(_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

                            self.differ(delline, addline)

                            raise

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

                            # there was only one add line - ok

                            self.differ(delline, addline)

                except StopIteration:

                    pass

        return diff_container(_files)

    def _parse_udiff(self, inline_diff=True):

        raise NotImplementedError()

    def _parse_lines(self, diff):

                     %endif

                     <% rev = c.changeset.extra.get('transplant_source', '').encode('hex') %>

                     %if rev:

                     <div>

                       ${_('Transplanted from:')} ${h.link_to(h.short_id(rev),h.url('changeset_home',repo_name=c.repo_name,revision=rev), class_="changeset_hash")}

                     </div>

                     %endif

                     % if hasattr(c.changeset, 'successors') and c.changeset.successors:

                     <div class='successors'>

                       <span class='successors_header'>${_('Replaced by:')} </span>

                       % for i, s in enumerate(c.changeset.successors):

                           <%

                           comma = ""

                           if i != len(c.changeset.successors)-1:

                             comma = ", "

                           %>

                         <a class='successors_hash' href="${h.url('changeset_home',repo_name=c.repo_name, revision=s)}">${s}</a>${comma}

                       % endfor

                     </div>

                     % endif

                     % if hasattr(c.changeset, 'precursors') and c.changeset.precursors:

                     <div class='precursors'>

                       <span class='precursors_header'>${_('Preceded by:')} </span>

                       % for i, s in enumerate(c.changeset.precursors):

                           <%

                           comma = ""

                           if i != len(c.changeset.precursors)-1:

                             comma = ", "

                           %>

                           <a class="precursors_hash" href="${h.url('changeset_home',repo_name=c.repo_name, revision=s)}">${s}</a>${comma}

                       % endfor

                     </div>

                     % endif

                     <div class="message">${h.urlify_text(c.changeset.message, c.repo_name)}</div>

                </div>

            </div>

            <div class="changes_txt">

              <% a_rev, cs_rev, file_diff_data = c.changes[c.changeset.raw_id] %>

              % if c.limited_diff:

                  ${ungettext('%s file changed', '%s files changed', len(file_diff_data)) % len(file_diff_data)}:

              % else:

                  ${ungettext('%s file changed with %s insertions and %s deletions', '%s files changed with %s insertions and %s deletions', len(file_diff_data)) % (len(file_diff_data), c.lines_added, c.lines_deleted)}:

              %endif

              </div>

              <div class="cs_files">

                    <div class="cs_${op}">

                      <div class="node">

                          <i class="icon-diff-${op}"></i>

                          ${h.link_to(h.safe_unicode(path), '#%s' % fid)}

                      </div>

                      <div class="changes">${h.fancy_file_stats(stats)}</div>

                    </div>

                %endfor

                %if c.limited_diff:

                  <h5>${_('Changeset was too big and was cut off...')} <a href="${h.url.current(fulldiff=1, **request.GET.mixed())}">${_('Show full diff anyway')}</a></h5>

                %endif

            </div>

        </div>

    </div>

    ## diff block

    <div class="commentable-diff">

    <%namespace name="diff_block" file="/changeset/diff_block.html"/>

    ${diff_block.diff_block_js()}

    <% a_rev, cs_rev, file_diff_data = c.changes[c.changeset.raw_id] %>

    ${diff_block.diff_block(c.repo_name, 'rev', a_rev, a_rev,

                            c.repo_name, 'rev', cs_rev, cs_rev, file_diff_data)}

    % if c.limited_diff:

      <h4>${_('Changeset was too big and was cut off...')} <a href="${h.url.current(fulldiff=1, **request.GET.mixed())}">${_('Show full diff anyway')}</a></h4>

    % endif

    </div>

    ## template for inline comment form

    ${comment.comment_inline_form()}

    ## render comments and inlines

    ${comment.generate_comments()}

    ## main comment form and it status

    ${comment.comments()}

    ## FORM FOR MAKING JS ACTION AS CHANGESET COMMENTS

    <script type="text/javascript">

      $(document).ready(function(){

          $('.code-difftable').on('click', '.add-bubble', function(e){

              show_comment_form($(this));

          });

          move_comments($(".comments .comments-list-chunk"));

          pyroutes.register('changeset_home',

                            "${h.url('changeset_home', repo_name='%(repo_name)s', revision='%(revision)s')}",

<%block name="header_menu">

    ${self.menu('repositories')}

</%block>

<%def name="main()">

${self.repo_context_bar('changelog')}

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}

    </div>

    <div class="table">

        <div id="body" class="diffblock">

            <div class="code-header">

                <div>

                    ${h.show_id(c.cs_ranges[0])}

                    <i class="icon-right"></i>

                    ${h.show_id(c.cs_ranges[-1])}

                    <a style="font-weight: bold" href="${h.url('compare_url',repo_name=c.repo_name,org_ref_type='rev',org_ref_name=getattr(c.cs_ranges[0].parents[0] if c.cs_ranges[0].parents else h.EmptyChangeset(),'raw_id'),other_ref_type='rev',other_ref_name=c.cs_ranges[-1].raw_id)}" class="btn btn-small"><i class="icon-git-compare"></i> Compare Revisions</a>

                </div>

            </div>

        </div>

        <div id="changeset_compare_view_content">

            <div class="container">

            <table class="compare_view_commits noborder">

            %for cnt,cs in enumerate(c.cs_ranges):

                <tr>

                %if c.visual.use_gravatar:

                <td>${h.gravatar_div(h.email_or_none(cs.author), size=14)}</td>

                %endif

                <td>${h.link_to('r%s:%s' % (cs.revision,h.short_id(cs.raw_id)),h.url('changeset_home',repo_name=c.cs_repo.repo_name,revision=cs.raw_id))}</td>

                <td><div class="author">${h.person(cs.author)}</div></td>

                <td><span class="tooltip" title="${h.age(cs.date)}">${cs.date}</span></td>

                <td>

                  %if c.statuses:

                    <div title="${_('Changeset status')}" class="changeset-status-ico"><i class="icon-circle changeset-status-${c.statuses[cnt]}"></i></div>

                  %endif

                </td>

                <td><div class="message">${h.urlify_text(h.wrap_paragraphs(cs.message),c.repo_name)}</div></td>

                </tr>

            %endfor

            </table>

            </div>

            <div style="font-size:1.1em;font-weight: bold;clear:both;padding-top:10px">${_('Files affected')}</div>

            <div class="cs_files">

                %for cs in c.cs_ranges:

                    <div class="cur_cs">${h.link_to(h.show_id(cs),h.url('changeset_home',repo_name=c.cs_repo.repo_name,revision=cs.raw_id))}</div>

                    <% a_rev, cs_rev, file_diff_data = c.changes[cs.raw_id] %>

                        <div class="cs_${op}">

                            <div class="node">

                                <i class="icon-diff-${op}"></i>

                                ${h.link_to(h.safe_unicode(path), '#%s' % fid)}

                            </div>

                            <div class="changes">${h.fancy_file_stats(stats)}</div>

                        </div>

                    %endfor

                %endfor

            </div>

        </div>

    </div>

    <%namespace name="comment" file="/changeset/changeset_file_comment.html"/>

    <%namespace name="diff_block" file="/changeset/diff_block.html"/>

    ${diff_block.diff_block_js()}

    %for cs in c.cs_ranges:

          ## diff block

          <div class="h3">

          <a class="tooltip" title="${cs.message}" href="${h.url('changeset_home',repo_name=c.cs_repo.repo_name,revision=cs.raw_id)}">${h.show_id(cs)}</a>

             ${h.gravatar_div(h.email_or_none(cs.author), size=20)}

             <div class="right">

              <span class="logtags">

                %if len(cs.parents)>1:

                <span class="merge">${_('Merge')}</span>

                %endif

                %if h.is_hg(c.db_repo_scm_instance):

                  %for book in cs.bookmarks:

                  <span class="booktag" title="${_('Bookmark %s') % book}">

                     ${h.link_to(book,h.url('changeset_home',repo_name=c.cs_repo.repo_name,revision=cs.raw_id))}

                  </span>

                  %endfor

                %endif

                %for tag in cs.tags:

                    <span class="tagtag" title="${_('Tag %s') % tag}">

                    ${h.link_to(tag,h.url('changeset_home',repo_name=c.cs_repo.repo_name,revision=cs.raw_id))}</span>

                %endfor

                %if cs.branch:

                <span class="branchtag" title="${_('Branch %s') % cs.branch}">

                   ${h.link_to(cs.branch,h.url('changeset_home',repo_name=c.cs_repo.repo_name,revision=cs.raw_id))}

                </span>

                %endif

              </span>

            </div>

           </div>

          <% a_rev, cs_rev, file_diff_data = c.changes[cs.raw_id] %>

          ${diff_block.diff_block(c.repo_name, 'rev', a_rev, a_rev,

                                  c.repo_name, 'rev', cs_rev, cs_rev, file_diff_data)}

## -*- coding: utf-8 -*-

<%def name="diff_block(a_repo_name, a_ref_type, a_ref_name, a_rev,

                       cs_repo_name, cs_ref_name, cs_ref_type, cs_rev,

                       file_diff_data)">

<div class="diff-collapse">

    <span target="${'diff-container-%s' % (id(file_diff_data))}" class="diff-collapse-button">&uarr; ${_('Collapse Diff')} &uarr;</span>

</div>

<div class="diff-container" id="${'diff-container-%s' % (id(file_diff_data))}">

%endfor

</div>

</%def>

>

    <div id="${id_fid}_target" style="clear:both;margin-top:25px"></div>

    <div id="${id_fid}" class="diffblock margined comm">

        <div class="code-header">

            <div class="changeset_header">

                <div class="changeset_file">

                    %if op == 'A':

                      ${_('Added')}

                    %elif op == 'M':

                      <i class="icon-right"></i>

                    %elif op == 'D':

                      ${_('Deleted')}

                    %elif op == 'R':

                      ${_('Renamed')}

                      <i class="icon-right"></i>

                    %else:

                      ${op}???