changeset: add new diffs to changeset controller

rhodecode/controllers/changeset.py

@@ -1,465 +1,469 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 commit controller for RhodeCode showing changes between commits
 """
 
 import logging
 
 from collections import defaultdict
 from webob.exc import HTTPForbidden, HTTPBadRequest, HTTPNotFound
 
 from pylons import tmpl_context as c, request, response
 from pylons.i18n.translation import _
 from pylons.controllers.util import redirect
 
 from rhodecode.lib import auth
-from rhodecode.lib import diffs
+from rhodecode.lib import diffs, codeblocks
 from rhodecode.lib.auth import (
     LoginRequired, HasRepoPermissionAnyDecorator, NotAnonymous)
 from rhodecode.lib.base import BaseRepoController, render
 from rhodecode.lib.compat import OrderedDict
 from rhodecode.lib.exceptions import StatusChangeOnClosedPullRequestError
 import rhodecode.lib.helpers as h
 from rhodecode.lib.utils import action_logger, jsonify
 from rhodecode.lib.utils2 import safe_unicode
 from rhodecode.lib.vcs.backends.base import EmptyCommit
 from rhodecode.lib.vcs.exceptions import (
     RepositoryError, CommitDoesNotExistError)
 from rhodecode.model.db import ChangesetComment, ChangesetStatus
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.comment import ChangesetCommentsModel
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
 
 
 log = logging.getLogger(__name__)
 
 
 def _update_with_GET(params, GET):
     for k in ['diff1', 'diff2', 'diff']:
         params[k] += GET.getall(k)
 
 
 def get_ignore_ws(fid, GET):
     ig_ws_global = GET.get('ignorews')
     ig_ws = filter(lambda k: k.startswith('WS'), GET.getall(fid))
     if ig_ws:
         try:
             return int(ig_ws[0].split(':')[-1])
         except Exception:
             pass
     return ig_ws_global
 
 
 def _ignorews_url(GET, fileid=None):
     fileid = str(fileid) if fileid else None
     params = defaultdict(list)
     _update_with_GET(params, GET)
     label = _('Show whitespace')
     tooltiplbl = _('Show whitespace for all diffs')
     ig_ws = get_ignore_ws(fileid, GET)
     ln_ctx = get_line_ctx(fileid, GET)
 
     if ig_ws is None:
         params['ignorews'] += [1]
         label = _('Ignore whitespace')
         tooltiplbl = _('Ignore whitespace for all diffs')
     ctx_key = 'context'
     ctx_val = ln_ctx
 
     # if we have passed in ln_ctx pass it along to our params
     if ln_ctx:
         params[ctx_key] += [ctx_val]
 
     if fileid:
         params['anchor'] = 'a_' + fileid
     return h.link_to(label, h.url.current(**params), title=tooltiplbl, class_='tooltip')
 
 
 def get_line_ctx(fid, GET):
     ln_ctx_global = GET.get('context')
     if fid:
         ln_ctx = filter(lambda k: k.startswith('C'), GET.getall(fid))
     else:
         _ln_ctx = filter(lambda k: k.startswith('C'), GET)
         ln_ctx = GET.get(_ln_ctx[0]) if _ln_ctx  else ln_ctx_global
         if ln_ctx:
             ln_ctx = [ln_ctx]
 
     if ln_ctx:
         retval = ln_ctx[0].split(':')[-1]
     else:
         retval = ln_ctx_global
 
     try:
         return int(retval)
     except Exception:
         return 3
 
 
 def _context_url(GET, fileid=None):
     """
     Generates a url for context lines.
 
     :param fileid:
     """
 
     fileid = str(fileid) if fileid else None
     ig_ws = get_ignore_ws(fileid, GET)
     ln_ctx = (get_line_ctx(fileid, GET) or 3) * 2
 
     params = defaultdict(list)
     _update_with_GET(params, GET)
 
     if ln_ctx > 0:
         params['context'] += [ln_ctx]
 
     if ig_ws:
         ig_ws_key = 'ignorews'
         ig_ws_val = 1
         params[ig_ws_key] += [ig_ws_val]
 
     lbl = _('Increase context')
     tooltiplbl = _('Increase context for all diffs')
 
     if fileid:
         params['anchor'] = 'a_' + fileid
     return h.link_to(lbl, h.url.current(**params), title=tooltiplbl, class_='tooltip')
 
 
 class ChangesetController(BaseRepoController):
 
     def __before__(self):
         super(ChangesetController, self).__before__()
         c.affected_files_cut_off = 60
 
     def _index(self, commit_id_range, method):
         c.ignorews_url = _ignorews_url
         c.context_url = _context_url
         c.fulldiff = fulldiff = request.GET.get('fulldiff')
         # get ranges of commit ids if preset
         commit_range = commit_id_range.split('...')[:2]
         enable_comments = True
         try:
             pre_load = ['affected_files', 'author', 'branch', 'date',
                         'message', 'parents']
 
             if len(commit_range) == 2:
                 enable_comments = False
                 commits = c.rhodecode_repo.get_commits(
                     start_id=commit_range[0], end_id=commit_range[1],
                     pre_load=pre_load)
                 commits = list(commits)
             else:
                 commits = [c.rhodecode_repo.get_commit(
                     commit_id=commit_id_range, pre_load=pre_load)]
 
             c.commit_ranges = commits
             if not c.commit_ranges:
                 raise RepositoryError(
                     'The commit range returned an empty result')
         except CommitDoesNotExistError:
             msg = _('No such commit exists for this repository')
             h.flash(msg, category='error')
             raise HTTPNotFound()
         except Exception:
             log.exception("General failure")
             raise HTTPNotFound()
 
         c.changes = OrderedDict()
         c.lines_added = 0
         c.lines_deleted = 0
 
         c.commit_statuses = ChangesetStatus.STATUSES
         c.comments = []
         c.statuses = []
         c.inline_comments = []
         c.inline_cnt = 0
         c.files = []
 
         # Iterate over ranges (default commit view is always one commit)
         for commit in c.commit_ranges:
             if method == 'show':
                 c.statuses.extend([ChangesetStatusModel().get_status(
                     c.rhodecode_db_repo.repo_id, commit.raw_id)])
 
                 c.comments.extend(ChangesetCommentsModel().get_comments(
                     c.rhodecode_db_repo.repo_id,
                     revision=commit.raw_id))
 
                 # comments from PR
                 st = ChangesetStatusModel().get_statuses(
                     c.rhodecode_db_repo.repo_id, commit.raw_id,
                     with_revisions=True)
 
                 # from associated statuses, check the pull requests, and
                 # show comments from them
 
                 prs = set(x.pull_request for x in
                           filter(lambda x: x.pull_request is not None, st))
                 for pr in prs:
                     c.comments.extend(pr.comments)
 
                 inlines = ChangesetCommentsModel().get_inline_comments(
                     c.rhodecode_db_repo.repo_id, revision=commit.raw_id)
                 c.inline_comments.extend(inlines.iteritems())
 
             c.changes[commit.raw_id] = []
 
             commit2 = commit
             commit1 = commit.parents[0] if commit.parents else EmptyCommit()
 
             # fetch global flags of ignore ws or context lines
             context_lcl = get_line_ctx('', request.GET)
             ign_whitespace_lcl = get_ignore_ws('', request.GET)
 
             _diff = c.rhodecode_repo.get_diff(
                 commit1, commit2,
                 ignore_whitespace=ign_whitespace_lcl, context=context_lcl)
 
             # diff_limit will cut off the whole diff if the limit is applied
             # otherwise it will just hide the big files from the front-end
             diff_limit = self.cut_off_limit_diff
             file_limit = self.cut_off_limit_file
 
             diff_processor = diffs.DiffProcessor(
-                _diff, format='gitdiff', diff_limit=diff_limit,
+                _diff, format='newdiff', diff_limit=diff_limit,
                 file_limit=file_limit, show_full_diff=fulldiff)
             commit_changes = OrderedDict()
             if method == 'show':
                 _parsed = diff_processor.prepare()
                 c.limited_diff = isinstance(_parsed, diffs.LimitedDiffContainer)
-                for f in _parsed:
-                    c.files.append(f)
-                    st = f['stats']
-                    c.lines_added += st['added']
-                    c.lines_deleted += st['deleted']
-                    fid = h.FID(commit.raw_id, f['filename'])
-                    diff = diff_processor.as_html(enable_comments=enable_comments,
-                                                  parsed_lines=[f])
-                    commit_changes[fid] = [
-                        commit1.raw_id, commit2.raw_id,
-                        f['operation'], f['filename'], diff, st, f]
+
+                _parsed = diff_processor.prepare()
+
+                def _node_getter(commit):
+                    def get_node(fname):
+                        try:
+                            return commit.get_node(fname)
+                        except NodeDoesNotExistError:
+                            return None
+                    return get_node
+
+                diffset = codeblocks.DiffSet(
+                    source_node_getter=_node_getter(commit1),
+                    target_node_getter=_node_getter(commit2),
+                ).render_patchset(_parsed, commit1.raw_id, commit2.raw_id)
+                c.changes[commit.raw_id] = diffset
             else:
                 # downloads/raw we only need RAW diff nothing else
                 diff = diff_processor.as_raw()
-                commit_changes[''] = [None, None, None, None, diff, None, None]
-            c.changes[commit.raw_id] = commit_changes
+                c.changes[commit.raw_id] = [None, None, None, None, diff, None, None]
 
         # sort comments by how they were generated
         c.comments = sorted(c.comments, key=lambda x: x.comment_id)
 
         # count inline comments
         for __, lines in c.inline_comments:
             for comments in lines.values():
                 c.inline_cnt += len(comments)
 
         if len(c.commit_ranges) == 1:
             c.commit = c.commit_ranges[0]
             c.parent_tmpl = ''.join(
                 '# Parent  %s\n' % x.raw_id for x in c.commit.parents)
         if method == 'download':
             response.content_type = 'text/plain'
             response.content_disposition = (
                 'attachment; filename=%s.diff' % commit_id_range[: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':
             if len(c.commit_ranges) == 1:
                 return render('changeset/changeset.html')
             else:
                 c.ancestor = None
                 c.target_repo = c.rhodecode_db_repo
                 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):
         return self._index(revision, method='raw')
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def changeset_patch(self, revision):
         return self._index(revision, method='patch')
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def changeset_download(self, revision):
         return self._index(revision, method='download')
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @auth.CSRFRequired()
     @jsonify
     def comment(self, repo_name, revision):
         commit_id = revision
         status = request.POST.get('changeset_status', None)
         text = request.POST.get('text')
         if status:
             text = text or (_('Status change %(transition_icon)s %(status)s')
                             % {'transition_icon': '>',
                                'status': ChangesetStatus.get_status_lbl(status)})
 
         multi_commit_ids = filter(
             lambda s: s not in ['', None],
             request.POST.get('commit_ids', '').split(','),)
 
         commit_ids = multi_commit_ids or [commit_id]
         comment = None
         for current_id in filter(None, commit_ids):
             c.co = comment = ChangesetCommentsModel().create(
                 text=text,
                 repo=c.rhodecode_db_repo.repo_id,
                 user=c.rhodecode_user.user_id,
                 revision=current_id,
                 f_path=request.POST.get('f_path'),
                 line_no=request.POST.get('line'),
                 status_change=(ChangesetStatus.get_status_lbl(status)
                                if status else None),
                 status_change_type=status
             )
             # get status if set !
             if status:
                 # if latest status was from pull request and it's closed
                 # disallow changing status !
                 # dont_allow_on_closed_pull_request = True !
 
                 try:
                     ChangesetStatusModel().set_status(
                         c.rhodecode_db_repo.repo_id,
                         status,
                         c.rhodecode_user.user_id,
                         comment,
                         revision=current_id,
                         dont_allow_on_closed_pull_request=True
                     )
                 except StatusChangeOnClosedPullRequestError:
                     msg = _('Changing the status of a commit associated with '
                             'a closed pull request is not allowed')
                     log.exception(msg)
                     h.flash(msg, category='warning')
                     return redirect(h.url(
                         'changeset_home', repo_name=repo_name,
                         revision=current_id))
 
         # finalize, commit and redirect
         Session().commit()
 
         data = {
             'target_id': h.safeid(h.safe_unicode(request.POST.get('f_path'))),
         }
         if comment:
             data.update(comment.get_dict())
             data.update({'rendered_text':
                          render('changeset/changeset_comment_block.html')})
 
         return data
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @auth.CSRFRequired()
     def preview_comment(self):
         # Technically a CSRF token is not needed as no state changes with this
         # call. However, as this is a POST is better to have it, so automated
         # tools don't flag it as potential CSRF.
         # Post is required because the payload could be bigger than the maximum
         # allowed by GET.
         if not request.environ.get('HTTP_X_PARTIAL_XHR'):
             raise HTTPBadRequest()
         text = request.POST.get('text')
         renderer = request.POST.get('renderer') or 'rst'
         if text:
             return h.render(text, renderer=renderer, mentions=True)
         return ''
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @auth.CSRFRequired()
     @jsonify
     def delete_comment(self, repo_name, comment_id):
         comment = ChangesetComment.get(comment_id)
         owner = (comment.author.user_id == c.rhodecode_user.user_id)
         is_repo_admin = h.HasRepoPermissionAny('repository.admin')(c.repo_name)
         if h.HasPermissionAny('hg.admin')() or is_repo_admin or owner:
             ChangesetCommentsModel().delete(comment=comment)
             Session().commit()
             return True
         else:
             raise HTTPForbidden()
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @jsonify
     def changeset_info(self, repo_name, revision):
         if request.is_xhr:
             try:
                 return c.rhodecode_repo.get_commit(commit_id=revision)
             except CommitDoesNotExistError as e:
                 return EmptyCommit(message=str(e))
         else:
             raise HTTPBadRequest()
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @jsonify
     def changeset_children(self, repo_name, revision):
         if request.is_xhr:
             commit = c.rhodecode_repo.get_commit(commit_id=revision)
             result = {"results": commit.children}
             return result
         else:
             raise HTTPBadRequest()
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @jsonify
     def changeset_parents(self, repo_name, revision):
         if request.is_xhr:
             commit = c.rhodecode_repo.get_commit(commit_id=revision)
             result = {"results": commit.parents}
             return result
         else:
             raise HTTPBadRequest()

rhodecode/templates/changeset/changeset.html

@@ -1,395 +1,317 b''
 ## -*- coding: utf-8 -*-
 
 <%inherit file="/base/base.html"/>
 <%namespace name="diff_block" file="/changeset/diff_block.html"/>
 
 <%def name="title()">
     ${_('%s Commit') % c.repo_name} - ${h.show_id(c.commit)}
     %if c.rhodecode_name:
         &middot; ${h.branding(c.rhodecode_name)}
     %endif
 </%def>
 
 <%def name="menu_bar_nav()">
     ${self.menu_items(active='repositories')}
 </%def>
 
 <%def name="menu_bar_subnav()">
     ${self.repo_menu(active='changelog')}
 </%def>
 
 <%def name="main()">
 <script>
     // TODO: marcink switch this to pyroutes
     AJAX_COMMENT_DELETE_URL = "${url('changeset_comment_delete',repo_name=c.repo_name,comment_id='__COMMENT_ID__')}";
     templateContext.commit_data.commit_id = "${c.commit.raw_id}";
 </script>
 <div class="box">
     <div class="title">
         ${self.repo_page_title(c.rhodecode_db_repo)}
     </div>
 
   <div id="changeset_compare_view_content"  class="summary changeset">
     <div class="summary-detail">
       <div class="summary-detail-header">
           <span class="breadcrumbs files_location">
             <h4>${_('Commit')}
               <code>
                 ${h.show_id(c.commit)}
               </code>
             </h4>
           </span>
           <span id="parent_link">
             <a href="#" title="${_('Parent Commit')}">${_('Parent')}</a>
           </span>
            | 
           <span id="child_link">
             <a href="#" title="${_('Child Commit')}">${_('Child')}</a>
           </span>
       </div>
   
       <div class="fieldset">
         <div class="left-label">
           ${_('Description')}:
         </div>
         <div class="right-content">
           <div id="trimmed_message_box" class="commit">${h.urlify_commit_message(c.commit.message,c.repo_name)}</div>
           <div id="message_expand" style="display:none;">
             ${_('Expand')}
           </div>
         </div>
       </div>
   
       %if c.statuses:
       <div class="fieldset">
         <div class="left-label">
           ${_('Commit status')}:
         </div>
         <div class="right-content">
           <div class="changeset-status-ico">
             <div class="${'flag_status %s' % c.statuses[0]} pull-left"></div>
           </div>
           <div title="${_('Commit status')}" class="changeset-status-lbl">[${h.commit_status_lbl(c.statuses[0])}]</div>
         </div>
       </div>
       %endif
   
       <div class="fieldset">
         <div class="left-label">
           ${_('References')}:
         </div>
         <div class="right-content">
           <div class="tags">
   
             %if c.commit.merge:
               <span class="mergetag tag">
                <i class="icon-merge"></i>${_('merge')}
               </span>
             %endif
   
             %if h.is_hg(c.rhodecode_repo):
               %for book in c.commit.bookmarks:
               <span class="booktag tag" title="${_('Bookmark %s') % book}">
                 <a href="${h.url('files_home',repo_name=c.repo_name,revision=c.commit.raw_id)}"><i class="icon-bookmark"></i>${h.shorter(book)}</a>
               </span>
               %endfor
             %endif
   
             %for tag in c.commit.tags:
              <span class="tagtag tag"  title="${_('Tag %s') % tag}">
               <a href="${h.url('files_home',repo_name=c.repo_name,revision=c.commit.raw_id)}"><i class="icon-tag"></i>${tag}</a>
              </span>
             %endfor
   
             %if c.commit.branch:
               <span class="branchtag tag" title="${_('Branch %s') % c.commit.branch}">
                 <a href="${h.url('files_home',repo_name=c.repo_name,revision=c.commit.raw_id)}"><i class="icon-code-fork"></i>${h.shorter(c.commit.branch)}</a>
               </span>
             %endif
             </div>
           </div>
         </div>
 
       <div class="fieldset">
         <div class="left-label">
           ${_('Diffs')}:
         </div>
         <div class="right-content">
             <div class="diff-actions">
               <a href="${h.url('changeset_raw_home',repo_name=c.repo_name,revision=c.commit.raw_id)}"  class="tooltip" title="${h.tooltip(_('Raw diff'))}">
                 ${_('Raw Diff')}
               </a>
                | 
               <a href="${h.url('changeset_patch_home',repo_name=c.repo_name,revision=c.commit.raw_id)}"  class="tooltip" title="${h.tooltip(_('Patch diff'))}">
                 ${_('Patch Diff')}
               </a>
                | 
               <a href="${h.url('changeset_download_home',repo_name=c.repo_name,revision=c.commit.raw_id,diff='download')}" class="tooltip" title="${h.tooltip(_('Download diff'))}">
                 ${_('Download Diff')}
               </a>
                | 
               ${c.ignorews_url(request.GET)}
                | 
               ${c.context_url(request.GET)}
             </div>
         </div>
       </div>
   
       <div class="fieldset">
         <div class="left-label">
           ${_('Comments')}:
         </div>
         <div class="right-content">
             <div class="comments-number">
                 %if c.comments:
                     <a href="#comments">${ungettext("%d Commit comment", "%d Commit comments", len(c.comments)) % len(c.comments)}</a>,
                 %else:
                     ${ungettext("%d Commit comment", "%d Commit comments", len(c.comments)) % len(c.comments)}
                 %endif
                 %if c.inline_cnt:
                     ## this is replaced with a proper link to first comment via JS linkifyComments() func
                     <a href="#inline-comments" id="inline-comments-counter">${ungettext("%d Inline Comment", "%d Inline Comments", c.inline_cnt) % c.inline_cnt}</a>
                 %else:
                     ${ungettext("%d Inline Comment", "%d Inline Comments", c.inline_cnt) % c.inline_cnt}
                 %endif
             </div>
         </div>
       </div>
   
     </div> <!-- end summary-detail -->
               
     <div id="commit-stats" class="sidebar-right">
       <div class="summary-detail-header">
         <h4 class="item">
           ${_('Author')}
         </h4>
       </div>
         <div class="sidebar-right-content">
             ${self.gravatar_with_user(c.commit.author)}
             <div class="user-inline-data">- ${h.age_component(c.commit.date)}</div>
         </div>
     </div><!-- end sidebar -->
   </div> <!-- end summary -->
-  <div class="cs_files_title">
-    <span class="cs_files_expand">
-        <span id="files_link"><a href="#" title="${_('Browse files at current commit')}">${_('Browse files')}</a></span> |
+  <div class="cs_files">
+  ${cbdiffs.render_diffset_menu()}
 
-        <span id="expand_all_files">${_('Expand All')}</span> | <span id="collapse_all_files">${_('Collapse All')}</span>
-    </span>
-    <h2>
-        ${diff_block.diff_summary_text(len(c.files), c.lines_added, c.lines_deleted, c.limited_diff)}
-    </h2>
+  <%namespace name="cbdiffs" file="/codeblocks/diffs.html"/>
+    ${cbdiffs.render_diffset(c.changes[c.commit.raw_id], commit=c.commit)}
   </div>
 </div> 
 
-<div class="cs_files">
-
-  %if not c.files:
-     <p class="empty_data">${_('No files')}</p>
-  %endif
-
-  <table class="compare_view_files commit_diff">
-      %for FID, (cs1, cs2, change, path, diff, stats, file) in c.changes[c.commit.raw_id].iteritems():
-        <tr class="cs_${change} collapse_file" fid="${FID}">
-          <td class="cs_icon_td">
-              <span class="collapse_file_icon" fid="${FID}"></span>
-          </td>
-          <td class="cs_icon_td">
-              <div class="flag_status not_reviewed hidden"></div>
-          </td>
-          <td class="cs_${change}" id="a_${FID}">
-            <div class="node">
-                <a href="#a_${FID}">
-                    <i class="icon-file-${change.lower()}"></i>
-                    ${h.safe_unicode(path)}
-                </a>
-            </div>
-          </td>
-          <td>
-            <div class="changes pull-right">${h.fancy_file_stats(stats)}</div>
-            <div class="comment-bubble pull-right" data-path="${path}">
-              <i class="icon-comment"></i>
-            </div>
-          </td>
-        </tr>
-        <tr fid="${FID}" id="diff_${FID}" class="diff_links">
-          <td></td>
-          <td></td>
-          <td class="cs_${change}">
-            ${diff_block.diff_menu(c.repo_name, h.safe_unicode(path), cs1, cs2, change, file)}
-          </td>
-          <td class="td-actions rc-form">
-            ${c.ignorews_url(request.GET, h.FID(cs2,path))} |
-            ${c.context_url(request.GET, h.FID(cs2,path))} |
-            <div data-comment-id="${h.FID(cs2,path)}" class="btn-link show-inline-comments comments-visible">
-              <span class="comments-show">${_('Show comments')}</span>
-              <span class="comments-hide">${_('Hide comments')}</span>
-            </div>
-          </td>
-        </tr>
-        <tr id="tr_${FID}">
-          <td></td>
-          <td></td>
-          <td class="injected_diff" colspan="2">
-            <div class="diff-container" id="${'diff-container-%s' % (id(change))}">
-              <div id="${FID}" class="diffblock margined comm">
-                <div class="code-body">
-                    <div class="full_f_path" path="${h.safe_unicode(path)}"></div>
-                    ${diff|n}
-                    % if file and file["is_limited_diff"]:
-                      % if file["exceeds_limit"]:
-                        ${diff_block.file_message()}
-                      % else:
-                        <h5>${_('Diff was truncated. File content available only in full diff.')} <a href="${h.url.current(fulldiff=1, **request.GET.mixed())}" onclick="return confirm('${_("Showing a big diff might take some time and resources, continue?")}')">${_('Show full diff')}</a></h5>
-                      % endif
-                    % endif
-                </div>
-              </div>
-            </div>
-          </td>
-        </tr>
-      %endfor
-  </table>
-</div>
-
-    % if c.limited_diff:
-          ${diff_block.changeset_message()}
-    % endif
-
     ## template for inline comment form
     <%namespace name="comment" file="/changeset/changeset_file_comment.html"/>
     ${comment.comment_inline_form()}
 
     ## render comments and inlines
     ${comment.generate_comments()}
 
     ## main comment form and it status
     ${comment.comments(h.url('changeset_comment', repo_name=c.repo_name, revision=c.commit.raw_id),
                        h.commit_status(c.rhodecode_db_repo, c.commit.raw_id))}
 
     ## FORM FOR MAKING JS ACTION AS CHANGESET COMMENTS
     <script type="text/javascript">
 
       $(document).ready(function() {
 
           var boxmax = parseInt($('#trimmed_message_box').css('max-height'), 10);
           if($('#trimmed_message_box').height() === boxmax){
               $('#message_expand').show();
           }
 
           $('#message_expand').on('click', function(e){
               $('#trimmed_message_box').css('max-height', 'none');
               $(this).hide();
           });
 
           $('.show-inline-comments').on('click', function(e){
               var boxid = $(this).attr('data-comment-id');
               var button = $(this);
 
               if(button.hasClass("comments-visible")) {
                 $('#{0} .inline-comments'.format(boxid)).each(function(index){
                   $(this).hide();
                 })
                 button.removeClass("comments-visible");
               } else {
                 $('#{0} .inline-comments'.format(boxid)).each(function(index){
                   $(this).show();
                 })
                 button.addClass("comments-visible");
               }
           });
 
 
           // next links
           $('#child_link').on('click', function(e){
               // fetch via ajax what is going to be the next link, if we have
               // >1 links show them to user to choose
               if(!$('#child_link').hasClass('disabled')){
                   $.ajax({
                     url: '${h.url('changeset_children',repo_name=c.repo_name, revision=c.commit.raw_id)}',
                     success: function(data) {
                       if(data.results.length === 0){
                           $('#child_link').html('${_('No Child Commits')}').addClass('disabled');
                       }
                       if(data.results.length === 1){
                           var commit = data.results[0];
                           window.location = pyroutes.url('changeset_home', {'repo_name': '${c.repo_name}','revision': commit.raw_id});
                       }
                       else if(data.results.length === 2){
                           $('#child_link').addClass('disabled');
                           $('#child_link').addClass('double');
                           var _html = '';
                           _html +='<a title="__title__" href="__url__">__rev__</a> '
                                   .replace('__rev__','r{0}:{1}'.format(data.results[0].revision, data.results[0].raw_id.substr(0,6)))
                                   .replace('__title__', data.results[0].message)
                                   .replace('__url__', pyroutes.url('changeset_home', {'repo_name': '${c.repo_name}','revision': data.results[0].raw_id}));
                           _html +=' | '
                           _html +='<a title="__title__" href="__url__">__rev__</a> '
                                   .replace('__rev__','r{0}:{1}'.format(data.results[1].revision, data.results[1].raw_id.substr(0,6)))
                                   .replace('__title__', data.results[1].message)
                                   .replace('__url__', pyroutes.url('changeset_home', {'repo_name': '${c.repo_name}','revision': data.results[1].raw_id}));
                           $('#child_link').html(_html);
                       }
                     }
                   });
                   e.preventDefault();
               }
           });
 
           // prev links
           $('#parent_link').on('click', function(e){
               // fetch via ajax what is going to be the next link, if we have
               // >1 links show them to user to choose
               if(!$('#parent_link').hasClass('disabled')){
                   $.ajax({
                     url: '${h.url('changeset_parents',repo_name=c.repo_name, revision=c.commit.raw_id)}',
                     success: function(data) {
                       if(data.results.length === 0){
                           $('#parent_link').html('${_('No Parent Commits')}').addClass('disabled');
                       }
                       if(data.results.length === 1){
                           var commit = data.results[0];
                           window.location = pyroutes.url('changeset_home', {'repo_name': '${c.repo_name}','revision': commit.raw_id});
                       }
                       else if(data.results.length === 2){
                           $('#parent_link').addClass('disabled');
                           $('#parent_link').addClass('double');
                           var _html = '';
                           _html +='<a title="__title__" href="__url__">Parent __rev__</a>'
                                   .replace('__rev__','r{0}:{1}'.format(data.results[0].revision, data.results[0].raw_id.substr(0,6)))
                                   .replace('__title__', data.results[0].message)
                                   .replace('__url__', pyroutes.url('changeset_home', {'repo_name': '${c.repo_name}','revision': data.results[0].raw_id}));
                           _html +=' | '
                           _html +='<a title="__title__" href="__url__">Parent __rev__</a>'
                                   .replace('__rev__','r{0}:{1}'.format(data.results[1].revision, data.results[1].raw_id.substr(0,6)))
                                   .replace('__title__', data.results[1].message)
                                   .replace('__url__', pyroutes.url('changeset_home', {'repo_name': '${c.repo_name}','revision': data.results[1].raw_id}));
                           $('#parent_link').html(_html);
                       }
                     }
                   });
                   e.preventDefault();
               }
           });
 
           if (location.hash) {
             var result = splitDelimitedHash(location.hash);
             var line = $('html').find(result.loc);
               if (line.length > 0){
                   offsetScroll(line, 70);
               }
           }
 
           // browse tree @ revision
           $('#files_link').on('click', function(e){
               window.location = '${h.url('files_home',repo_name=c.repo_name, revision=c.commit.raw_id, f_path='')}';
               e.preventDefault();
           });
 
           // inject comments into their proper positions
           var file_comments = $('.inline-comment-placeholder');
           renderInlineComments(file_comments, true);
       })
     </script>
 
 </%def>

rhodecode/templates/changeset/changeset_range.html

@@ -1,126 +1,71 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${_('%s Commits') % c.repo_name} -
     r${c.commit_ranges[0].revision}:${h.short_id(c.commit_ranges[0].raw_id)}
     ...
     r${c.commit_ranges[-1].revision}:${h.short_id(c.commit_ranges[-1].raw_id)}
     ${ungettext('(%s commit)','(%s commits)', len(c.commit_ranges)) % len(c.commit_ranges)}
     %if c.rhodecode_name:
         &middot; ${h.branding(c.rhodecode_name)}
     %endif
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${_('Commits')} -
     r${c.commit_ranges[0].revision}:${h.short_id(c.commit_ranges[0].raw_id)}
     ...
     r${c.commit_ranges[-1].revision}:${h.short_id(c.commit_ranges[-1].raw_id)}
     ${ungettext('(%s commit)','(%s commits)', len(c.commit_ranges)) % len(c.commit_ranges)}
 </%def>
 
 <%def name="menu_bar_nav()">
     ${self.menu_items(active='repositories')}
 </%def>
 
 <%def name="menu_bar_subnav()">
     ${self.repo_menu(active='changelog')}
 </%def>
 
 <%def name="main()">
   <div class="summary-header">
       <div class="title">
         <div class="title-content">
           ${self.repo_page_title(c.rhodecode_db_repo)}
         </div>
       </div>
       <div class="header-buttons">
         <a href="${h.url('compare_url', repo_name=c.repo_name, source_ref_type='rev', source_ref=getattr(c.commit_ranges[0].parents[0] if c.commit_ranges[0].parents else h.EmptyCommit(), 'raw_id'), target_ref_type='rev', target_ref=c.commit_ranges[-1].raw_id)}"
            class="btn btn-default">
             ${_('Show combined compare')}
         </a>
       </div>
   </div>
 
   <div class="summary-detail">
     <div class="title">
       <h2>
         ${self.breadcrumbs_links()}
       </h2>
     </div>
-
+  </div>
     <div id="changeset_compare_view_content">
       ##CS
       <%include file="../compare/compare_commits.html"/>
-      ## FILES
-      <div class="cs_files_title">
-        <span class="cs_files_expand">
-            <span id="expand_all_files">${_('Expand All')}</span> | <span id="collapse_all_files">${_('Collapse All')}</span>
-        </span>
-        <h2>
-            ${diff_block.diff_summary_text(len(c.files), c.lines_added, c.lines_deleted, c.limited_diff)}
-        </h2>
-      </div>
-    </div>
-  </div>
-
   <div class="cs_files">
-    <table class="compare_view_files">
+      ${cbdiffs.render_diffset_menu()}
+      <%namespace name="cbdiffs" file="/codeblocks/diffs.html"/>
       <%namespace name="comment" file="/changeset/changeset_file_comment.html"/>
       <%namespace name="diff_block" file="/changeset/diff_block.html"/>
-      %for cs in c.commit_ranges:
-        <tr class="rctable">
-          <td colspan="4">
-              <a class="tooltip revision" title="${h.tooltip(cs.message)}" href="${h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id)}">${'r%s:%s' % (cs.revision,h.short_id(cs.raw_id))}</a> |
-              ${h.age_component(cs.date)}
-          </td>
-        </tr>
-          %for FID, (cs1, cs2, change, path, diff, stats, file) in c.changes[cs.raw_id].iteritems():
-            <tr class="cs_${change} collapse_file" fid="${FID}">
-              <td class="cs_icon_td">
-                  <span class="collapse_file_icon" fid="${FID}"></span>
-              </td>
-              <td class="cs_icon_td">
-                  <div class="flag_status not_reviewed hidden"></div>
-              </td>
-              <td class="cs_${change}" id="a_${FID}">
-                <div class="node">
-                    <a href="#a_${FID}">
-                        <i class="icon-file-${change.lower()}"></i>
-                        ${h.safe_unicode(path)}
-                    </a>
-                </div>
-              </td>
-              <td>
-                <div class="changes">${h.fancy_file_stats(stats)}</div>
-              </td>
-            </tr>
-            <tr fid="${FID}" id="diff_${FID}" class="diff_links">
-              <td></td>
-              <td></td>
-              <td class="cs_${change}">
-                ${diff_block.diff_menu(c.repo_name, h.safe_unicode(path), cs1, cs2, change, file)}
-              </td>
-              <td class="td-actions rc-form"></td>
-            </tr>
-            <tr id="tr_${FID}">
-              <td></td>
-              <td></td>
-              <td class="injected_diff" colspan="2">
-                <div id="diff-container-${FID}" class="diff-container">
-                  <div id="${FID}" class="diffblock margined comm">
-                    <div class="code-body">
-                      ${diff|n}
-                    </div>
-                  </div>
-                </div>
-              </td>
-            </tr>
-          %endfor
+      %for commit in c.commit_ranges:
+        ${cbdifss.render_diffset(
+            diffset=c.changes[commit.raw_id],
+            collapse_when_files_over=5,
+            commit=commit,
+         )}
       %endfor
     </table>
   </div>
-## end summary detail
-
-</%def>
  No newline at end of file
+  </div>
+</%def>

rhodecode/templates/codeblocks/diffs.html

@@ -1,420 +1,420 b''
 <%def name="diff_line_anchor(filename, line, type)"><%
 return '%s_%s_%i' % (h.safeid(filename), type, line)
 %></%def>
 
 <%def name="action_class(action)"><%
     return {
         '-': 'cb-deletion',
         '+': 'cb-addition',
         ' ': 'cb-context',
         }.get(action, 'cb-empty')
 %></%def>
 
 <%def name="op_class(op_id)"><%
     return {
         DEL_FILENODE: 'deletion', # file deleted
         BIN_FILENODE: 'warning' # binary diff hidden
     }.get(op_id, 'addition')
 %></%def>
 
 <%def name="link_for(**kw)"><%
 new_args = request.GET.mixed()
 new_args.update(kw)
 return h.url('', **new_args)
 %></%def>
 
 <%def name="render_diffset(diffset, commit=None,
 
     # collapse all file diff entries when there are more than this amount of files in the diff
     collapse_when_files_over=20,
 
     # collapse lines in the diff when more than this amount of lines changed in the file diff
     lines_changed_limit=500,
 
     # add a ruler at to the output
     ruler_at_chars=0,
 
 )">
 <%
 collapse_all = len(diffset.files) > collapse_when_files_over
 %>
 
 %if c.diffmode == 'sideside':
 <style>
 .wrapper {
     max-width: 1600px !important;
 }
 </style>
 %endif
 %if ruler_at_chars:
 <style>
 .diff table.cb .cb-content:after {
     content: "";
     border-left: 1px solid blue;
     position: absolute;
     top: 0;
     height: 18px;
     opacity: .2;
     z-index: 10;
     ## +5 to account for diff action (+/-)
     left: ${ruler_at_chars + 5}ch;
 </style>
 %endif
 
 <div class="diffset">
     <div class="diffset-heading ${diffset.limited_diff and 'diffset-heading-warning' or ''}">
         %if commit:
             <div class="pull-right">
                 <a class="btn tooltip" title="${_('Browse Files at revision {}').format(commit.raw_id)}" href="${h.url('files_home',repo_name=c.repo_name, revision=commit.raw_id, f_path='')}">
                     ${_('Browse Files')}
                 </a>
             </div>
         %endif
         <h2 class="clearinner">
         %if commit:
             <a class="tooltip revision" title="${h.tooltip(commit.message)}" href="${h.url('changeset_home',repo_name=c.repo_name,revision=commit.raw_id)}">${'r%s:%s' % (commit.revision,h.short_id(commit.raw_id))}</a> -
             ${h.age_component(commit.date)} -
         %endif
     %if diffset.limited_diff:
     ${_('The requested commit is too big and content was truncated.')}
 
         ${ungettext('%(num)s file changed.', '%(num)s files changed.', diffset.changed_files) % {'num': diffset.changed_files}}
         <a href="${link_for(fulldiff=1)}" onclick="return confirm('${_("Showing a big diff might take some time and resources, continue?")}')">${_('Show full diff')}</a>
     %else:
         ${ungettext('%(num)s file changed: %(linesadd)s inserted, ''%(linesdel)s deleted',
                     '%(num)s files changed: %(linesadd)s inserted, %(linesdel)s deleted', diffset.changed_files) % {'num': diffset.changed_files, 'linesadd': diffset.lines_added, 'linesdel': diffset.lines_deleted}}
     %endif
         </h2>
     </div>
 
     %if not diffset.files:
         <p class="empty_data">${_('No files')}</p>
     %endif
 
     <div class="filediffs">
     %for i, filediff in enumerate(diffset.files):
     <%
     lines_changed = filediff['patch']['stats']['added'] + filediff['patch']['stats']['deleted']
     over_lines_changed_limit = lines_changed > lines_changed_limit
     %>
         <input ${collapse_all and 'checked' or ''} class="filediff-collapse-state" id="filediff-collapse-${id(filediff)}" type="checkbox">
         <div
             class="filediff"
             data-f-path="${filediff['patch']['filename']}"
             id="a_${h.FID(commit and commit.raw_id or '', filediff['patch']['filename'])}">
             <label for="filediff-collapse-${id(filediff)}" class="filediff-heading">
                 <div class="filediff-collapse-indicator"></div>
                 ${diff_ops(filediff)}
             </label>
             ${diff_menu(filediff)}
             <table class="cb cb-diff-${c.diffmode} code-highlight ${over_lines_changed_limit and 'cb-collapsed' or ''}">
         %if not filediff.hunks:
             %for op_id, op_text in filediff['patch']['stats']['ops'].items():
                 <tr>
                     <td class="cb-text cb-${op_class(op_id)}" ${c.diffmode == 'unified' and 'colspan=3' or 'colspan=4'}>
                         %if op_id == DEL_FILENODE:
                         ${_('File was deleted')}
                         %elif op_id == BIN_FILENODE:
                         ${_('Binary file hidden')}
                         %else:
                         ${op_text}
                         %endif
                     </td>
                 </tr>
             %endfor
         %endif
         %if over_lines_changed_limit:
                 <tr class="cb-warning cb-collapser">
                     <td class="cb-text" ${c.diffmode == 'unified' and 'colspan=3' or 'colspan=4'}>
                         ${_('This diff has been collapsed as it changes many lines, (%i lines changed)' % lines_changed)}
                         <a href="#" class="cb-expand"
                            onclick="$(this).closest('table').removeClass('cb-collapsed'); return false;">${_('Show them')}
                         </a>
                         <a href="#" class="cb-collapse"
                            onclick="$(this).closest('table').addClass('cb-collapsed'); return false;">${_('Hide them')}
                         </a>
                     </td>
                 </tr>
         %endif
         %if filediff.patch['is_limited_diff']:
                 <tr class="cb-warning cb-collapser">
                     <td class="cb-text" ${c.diffmode == 'unified' and 'colspan=3' or 'colspan=4'}>
                         ${_('The requested commit is too big and content was truncated.')} <a href="${link_for(fulldiff=1)}" onclick="return confirm('${_("Showing a big diff might take some time and resources, continue?")}')">${_('Show full diff')}</a>
                     </td>
                 </tr>
         %endif
         %for hunk in filediff.hunks:
                 <tr class="cb-hunk">
                     <td ${c.diffmode == 'unified' and 'colspan=2' or ''}>
                         ## TODO: dan: add ajax loading of more context here
                         ## <a href="#">
                             <i class="icon-more"></i>
                         ## </a>
                     </td>
                     <td ${c.diffmode == 'sideside' and 'colspan=3' or ''}>
                         @@
                         -${hunk.source_start},${hunk.source_length}
                         +${hunk.target_start},${hunk.target_length}
                         ${hunk.section_header}
                     </td>
                 </tr>
             %if c.diffmode == 'unified':
                     ${render_hunk_lines_unified(hunk)}
             %elif c.diffmode == 'sideside':
                     ${render_hunk_lines_sideside(hunk)}
             %else:
                 <tr class="cb-line">
                     <td>unknown diff mode</td>
                 </tr>
             %endif
         %endfor
             </table>
         </div>
     %endfor
     </div>
 </div>
 </%def>
 
 <%def name="diff_ops(filediff)">
 <%
 stats = filediff['patch']['stats']
 from rhodecode.lib.diffs import NEW_FILENODE, DEL_FILENODE, \
     MOD_FILENODE, RENAMED_FILENODE, CHMOD_FILENODE, BIN_FILENODE
 %>
     <span class="pill">
         %if filediff.source_file_path and filediff.target_file_path:
             %if filediff.source_file_path != filediff.target_file_path: # file was renamed
                   <strong>${filediff.target_file_path}</strong> ⬅ <del>${filediff.source_file_path}</del>
             %else:
                 ## file was modified
                 <strong>${filediff.source_file_path}</strong>
             %endif
         %else:
             %if filediff.source_file_path:
                 ## file was deleted
                 <strong>${filediff.source_file_path}</strong>
             %else:
                 ## file was added
                 <strong>${filediff.target_file_path}</strong>
             %endif
         %endif
     </span>
     <span class="pill-group" style="float: left">
         %if filediff.patch['is_limited_diff']:
         <span class="pill tooltip" op="limited" title="The stats for this diff are not complete">limited diff</span>
         %endif
         %if RENAMED_FILENODE in stats['ops']:
         <span class="pill" op="renamed">renamed</span>
         %endif
 
         %if NEW_FILENODE in stats['ops']:
         <span class="pill" op="created">created</span>
             %if filediff['target_mode'].startswith('120'):
         <span class="pill" op="symlink">symlink</span>
             %else:
         <span class="pill" op="mode">${nice_mode(filediff['target_mode'])}</span>
             %endif
         %endif
 
         %if DEL_FILENODE in stats['ops']:
         <span class="pill" op="removed">removed</span>
         %endif
 
         %if CHMOD_FILENODE in stats['ops']:
         <span class="pill" op="mode">
             ${nice_mode(filediff['source_mode'])} ➡ ${nice_mode(filediff['target_mode'])}
         </span>
         %endif
     </span>
 
     <a class="pill filediff-anchor" href="#a_${h.FID(commit and commit.raw_id or '', filediff.patch['filename'])}">¶</a>
 
     <span class="pill-group" style="float: right">
         %if BIN_FILENODE in stats['ops']:
         <span class="pill" op="binary">binary</span>
             %if MOD_FILENODE in stats['ops']:
             <span class="pill" op="modified">modified</span>
             %endif
         %endif
         %if stats['added']:
         <span class="pill" op="added">+${stats['added']}</span>
         %endif
         %if stats['deleted']:
         <span class="pill" op="deleted">-${stats['deleted']}</span>
         %endif
     </span>
 
 </%def>
 
 <%def name="nice_mode(filemode)">
     ${filemode.startswith('100') and filemode[3:] or filemode}
 </%def>
 
 <%def name="diff_menu(filediff)">
     <div class="filediff-menu">
 %if filediff.diffset.source_ref:
     %if filediff.patch['operation'] in ['D', 'M']:
         <a
             class="tooltip"
             href="${h.url('files_home',repo_name=c.repo_name,f_path=filediff.source_file_path,revision=filediff.diffset.source_ref)}"
             title="${h.tooltip(_('Show file at commit: %(commit_id)s') % {'commit_id': filediff.diffset.source_ref[:12]})}"
         >
             ${_('Show file before')}
         </a>
     %else:
         <span
             class="tooltip"
             title="${h.tooltip(_('File no longer present at commit: %(commit_id)s') % {'commit_id': filediff.diffset.source_ref[:12]})}"
         >
             ${_('Show file before')}
         </span>
     %endif
     %if filediff.patch['operation'] in ['A', 'M']:
         <a
             class="tooltip"
             href="${h.url('files_home',repo_name=c.repo_name,f_path=filediff.target_file_path,revision=filediff.diffset.target_ref)}"
             title="${h.tooltip(_('Show file at commit: %(commit_id)s') % {'commit_id': filediff.diffset.target_ref[:12]})}"
         >
             ${_('Show file after')}
         </a>
     %else:
         <span
             class="tooltip"
             title="${h.tooltip(_('File no longer present at commit: %(commit_id)s') % {'commit_id': filediff.diffset.target_ref[:12]})}"
             >
                 ${_('Show file after')}
         </span>
     %endif
         <a
             class="tooltip"
             title="${h.tooltip(_('Raw diff'))}"
             href="${h.url('files_diff_home',repo_name=c.repo_name,f_path=filediff.target_file_path,diff2=filediff.diffset.target_ref,diff1=filediff.diffset.source_ref,diff='raw')}"
         >
             ${_('Raw diff')}
         </a>
         <a
             class="tooltip"
             title="${h.tooltip(_('Download diff'))}"
             href="${h.url('files_diff_home',repo_name=c.repo_name,f_path=filediff.target_file_path,diff2=filediff.diffset.target_ref,diff1=filediff.diffset.source_ref,diff='download')}"
         >
             ${_('Download diff')}
         </a>
 %endif
     </div>
 </%def>
 
 
 <%def name="render_hunk_lines_sideside(hunk)">
     %for i, line in enumerate(hunk.sideside):
     <%
     old_line_anchor, new_line_anchor = None, None
     if line.original.lineno:
         old_line_anchor = diff_line_anchor(hunk.filediff.source_file_path, line.original.lineno, 'o')
     if line.modified.lineno:
         new_line_anchor = diff_line_anchor(hunk.filediff.target_file_path, line.modified.lineno, 'n')
     %>
     <tr class="cb-line">
         <td class="cb-lineno ${action_class(line.original.action)}"
             data-line-number="${line.original.lineno}"
             %if old_line_anchor:
             id="${old_line_anchor}"
             %endif
         >
             %if line.original.lineno:
             <a name="${old_line_anchor}" href="#${old_line_anchor}">${line.original.lineno}</a>
             %endif
         </td>
         <td class="cb-content ${action_class(line.original.action)}"
             data-line-number="o${line.original.lineno}"
             ><span class="cb-code">${line.original.action} ${line.original.content or '' | n}</span>
         </td>
         <td class="cb-lineno ${action_class(line.modified.action)}"
             data-line-number="${line.modified.lineno}"
             %if new_line_anchor:
             id="${new_line_anchor}"
             %endif
             >
             %if line.modified.lineno:
                 <a name="${new_line_anchor}" href="#${new_line_anchor}">${line.modified.lineno}</a>
             %endif
             </td>
         <td class="cb-content ${action_class(line.modified.action)}"
             data-line-number="n${line.modified.lineno}"
             >
             <span class="cb-code">${line.modified.action} ${line.modified.content or '' | n}</span>
         </td>
     </tr>
     %endfor
 </%def>
 
 
 <%def name="render_hunk_lines_unified(hunk)">
     %for old_line_no, new_line_no, action, content in hunk.unified:
     <%
     old_line_anchor, new_line_anchor = None, None
     if old_line_no:
         old_line_anchor = diff_line_anchor(hunk.filediff.source_file_path, old_line_no, 'o')
     if new_line_no:
         new_line_anchor = diff_line_anchor(hunk.filediff.target_file_path, new_line_no, 'n')
     %>
     <tr class="cb-line">
         <td class="cb-lineno ${action_class(action)}"
             data-line-number="${old_line_no}"
             %if old_line_anchor:
             id="${old_line_anchor}"
             %endif
         >
             %if old_line_anchor:
             <a name="${old_line_anchor}" href="#${old_line_anchor}">${old_line_no}</a>
             %endif
         </td>
         <td class="cb-lineno ${action_class(action)}"
             data-line-number="${new_line_no}"
             %if new_line_anchor:
             id="${new_line_anchor}"
             %endif
         >
             %if new_line_anchor:
             <a name="${new_line_anchor}" href="#${new_line_anchor}">${new_line_no}</a>
             %endif
         </td>
         <td class="cb-content ${action_class(action)}"
             data-line-number="${new_line_no and 'n' or 'o'}${new_line_no or old_line_no}"
             ><span class="cb-code">${action} ${content or '' | n}</span>
           </td>
     </tr>
     %endfor
 </%def>
 
 
 <%def name="render_diffset_menu()">
     <div class="diffset-menu clearinner">
         <div class="pull-right">
             <div class="btn-group">
                 <a
                   class="btn ${c.diffmode == 'sideside' and 'btn-primary'} tooltip"
                   title="${_('View side by side')}"
                   href="${h.url_replace(diffmode='sideside')}">
                     <span>${_('Side by Side')}</span>
                 </a>
                 <a
                   class="btn ${c.diffmode == 'unified' and 'btn-primary'} tooltip"
                   title="${_('View unified')}" href="${h.url_replace(diffmode='unified')}">
                     <span>${_('Unified')}</span>
                 </a>
             </div>
         </div>
         <div class="pull-left">
           <div class="btn-group">
               <a
                   class="btn"
                   href="#"
                   onclick="$('input[class=filediff-collapse-state]').prop('checked', false); return false">${_('Expand All')}</a>
               <a
                   class="btn"
                   href="#"
                   onclick="$('input[class=filediff-collapse-state]').prop('checked', true); return false">${_('Collapse All')}</a>
           </div>
         </div>
     </div>
-</%def>
  No newline at end of file
+</%def>