Ticket #199: diff_module_alpha1.diff

htdocs/css/browser.css

@@ -45 +45 @@
 #dirlist td.name a, #dirlist td.rev a { border-bottom: none; display: block }
 #dirlist td.change * { font-size: 9px }
 
+/* Log */
+#diff { margin: 0; }
+
 /* Styles for the revision log table
    (extends the styles for "table.listing") */
 #chglist { margin-top: 0 }

trac/db_default.py

@@ -458 +458 @@
 
 default_components = ('trac.About', 'trac.attachment', 'trac.Browser',
                       'trac.Changeset', 'trac.Search', 'trac.Settings',
+                      'trac.Diff',
                       'trac.ticket.query', 'trac.ticket.report',
                       'trac.Roadmap',
                       'trac.ticket.web_ui', 'trac.Timeline', 'trac.wiki.web_ui',

trac/versioncontrol/svn_fs.py

@@ -27 +27 @@
 import os.path
 import time
 import weakref
+import posixpath
 
 from svn import fs, repos, core, delta
 
@@ -176 +177 @@
         self.close()
 
     def normalize_path(self, path):
-        return path == '/' and path or path.strip('/')
+        return path == '/' and path or path and path.strip('/') or ''
 
     def normalize_rev(self, rev):
         try:
@@ -361 +362 @@
             props[name] = str(value) # Make sure the value is a proper string
         return props
 
+    def get_diff(self, older_node, ignore_ancestry=1):
+        if self.isfile and not older_node.isfile:
+            raise TracError, "Trying to diff a %s with a %s." % (self.kind, older_node.kind)
+        editor = DiffChangeEditor()
+        e_ptr, e_baton = delta.make_editor(editor, self.pool)
+        old_root = fs.revision_root(self.fs_ptr, older_node.created_rev, self.pool)
+        new_root = fs.revision_root(self.fs_ptr, self.created_rev, self.pool)
+        if older_node.isfile:
+            old_dir, old_entry = posixpath.split(older_node.created_path)
+        else:
+            old_dir, old_entry = older_node.created_path, ''
+        def authz_cb(root, path, pool): return 1
+        text_deltas = 0 # as this is currently redone in Diff.py... 
+        repos.svn_repos_dir_delta(old_root, old_dir, old_entry,
+                                  new_root, self.created_path, e_ptr, e_baton, authz_cb,
+                                  text_deltas, self.isdir, 0, ignore_ancestry, self.pool)
+        for d in editor.deltas:
+            yield d
+
     def get_content_length(self):
         if self.isdir:
             return None
@@ -450 +470 @@
 
     def _get_prop(self, name):
         return fs.revision_prop(self.fs_ptr, self.rev, name, self.pool)
+
+
+#
+# Delta editor for diffs between arbitrary nodes (recycling my old code for #295 :) )
+#
+# Note 1: the 'copyfrom_path' and 'copyfrom_rev' information is not used
+#         because 'repos.svn_repos_dir_delta' *doesn't* provide it.
+#
+# Note 2: the 'dir_baton' is the path of the parent directory
+#
+
+class DiffChangeEditor(delta.Editor): 
+
+    def __init__(self):
+        self.deltas = []
+        self.skip_dir_prop_change = 0
+
+    def _norm(self, path):
+        """Path are normalized to __not__ have a leading slash"""
+        return path == '/' and path or path and path.strip('/') or ''
+    
+    # -- svn.delta.Editor callbacks
+
+    def open_root(self, base_revision, dir_pool):
+        return '/'
+
+    def add_directory(self, path, dir_baton, copyfrom_path, copyfrom_rev, dir_pool):
+        self.deltas.append((path, Node.DIRECTORY, Changeset.ADD))
+        # don't create an additional 'Changeset.EDIT' entry for this directory
+        # in case there's also a dir property change:
+        self.skip_dir_prop_change = 1 
+        return path
+
+    def open_directory(self, path, dir_baton, base_revision, dir_pool):
+        self.deltas.append((path, Node.DIRECTORY, Changeset.EDIT))
+        self.skip_dir_prop_change = 0
+        return path
+
+    def change_dir_prop(self, dir_baton, name, value, pool):
+        if self.skip_dir_prop_change:
+            return
+        self.deltas.append((dir_baton, Node.DIRECTORY, Changeset.EDIT))
+        self.skip_dir_prop_change = 1
+
+    def close_directory(self, dir_baton):
+        self.skip_dir_prop_change = 0
+
+    def delete_entry(self, path, revision, dir_baton, pool):
+        self.deltas.append((path, Node.FILE, Changeset.DELETE)) # should be Node.UNKNOWN
+
+    def add_file(self, path, dir_baton, copyfrom_path, copyfrom_revision, dir_pool):
+        self.deltas.append((self._norm(path), Node.FILE, Changeset.ADD))
+
+    def open_file(self, path, dir_baton, dummy_rev, file_pool):
+        self.deltas.append((self._norm(path), Node.FILE, Changeset.EDIT))
+

trac/versioncontrol/main.py

@@ -162 +162 @@
         """
         raise NotImplementedError
 
+    def get_diff(self, older_node, ignore_ancestry=1):
+        """
+        Generator that yields (path, kind, chg) tuples representing
+        the diffs to this node, from the older node given as parameter.
+        """
+        raise NotImplementedError
+
     def get_content_length(self):
         raise NotImplementedError
     content_length = property(lambda x: x.get_content_length())

trac/Diff.py

@@ -24 +24 @@
 from __future__ import generators
 import time
 import re
+import posixpath
 
 from trac import mimeview, perm, util
 from trac.core import *
-from trac.Timeline import ITimelineEventProvider
 from trac.versioncontrol import Changeset, Node
 from trac.versioncontrol.diff import get_diff_options, hdf_diff, unified_diff
 from trac.web.chrome import add_link, add_stylesheet
@@ -35 +35 @@
 from trac.wiki import wiki_to_html, wiki_to_oneliner
 
 
-class ChangesetModule(Component):
+class Diff(dict):
+    def __getattr__(self,str):
+        return self[str]
+    
 
-    implements(IRequestHandler, ITimelineEventProvider)
+class DiffModule(Component):
 
+    implements(IRequestHandler)
+
     # IRequestHandler methods
 
     def match_request(self, req):
-        match = re.match(r'/changeset/([0-9]+)$', req.path_info)
+        print 'match_request in DiffModule'
+        match = re.match(r'/diff(?:(/.*)|$)', req.path_info)
         if match:
-            req.args['rev'] = match.group(1)
+            req.args['path'] = match.group(1)
             return 1
 
     def process_request(self, req):
         req.perm.assert_permission(perm.CHANGESET_VIEW)
 
-        rev = req.args.get('rev')
+        path = req.args.get('path')
         repos = self.env.get_repository(req.authname)
+        path = repos.normalize_path(path)
+        rev = req.args.get('rev', repos.youngest_rev) # 'path history' mode
+        old = req.args.get('old')                     # 'arbitrary diff' mode
+        new = req.args.get('new')
+        old_path = req.args.get('old_path', path)
 
         diff_options = get_diff_options(req)
         if req.args.has_key('update'):
-            req.redirect(self.env.href.changeset(rev))
+            if old or new:
+                req.redirect(self.env.href.diff(path, new=new, old_path=old_path, old=old))
+            else:
+                req.redirect(self.env.href.diff(path, rev=rev))
 
-        chgset = repos.get_changeset(rev)
-        req.check_modified(chgset.date,
-                           diff_options[0] + ''.join(diff_options[1]))
+        if old or new:
+            chgset = None
+            if not new:
+                new = repos.next_rev(old) # FIXME: must lookup the next entry in node history
+            elif not old:
+                old = repos.previous_rev(new)
+            if not old_path:
+                old_path = path
+            diff = Diff(old_path=old_path, old_rev=old,
+                        new_path=path, new_rev=new)
+        else:
+            chgset = repos.get_changeset(rev)
+            diff = Diff(old_path=path, old_rev=repos.previous_rev(rev),
+                        new_path=path, new_rev=rev)
+        
+        # TODO:
+#         req.check_modified(chgset.date,
+#                            diff_options[0] + ''.join(diff_options[1]))
 
         format = req.args.get('format')
         if format == 'diff':
-            self._render_diff(req, repos, chgset, diff_options)
+            self._render_diff(req, repos, diff, chgset, diff_options)
             return
         elif format == 'zip':
-            self._render_zip(req, repos, chgset)
+            self._render_zip(req, repos, diff, chgset)
             return
 
-        self._render_html(req, repos, chgset, diff_options)
+        self._render_html(req, repos, diff, chgset, diff_options)
         add_link(req, 'alternate', '?format=diff', 'Unified Diff',
                  'text/plain', 'diff')
         add_link(req, 'alternate', '?format=zip', 'Zip Archive',
                  'application/zip', 'zip')
         add_stylesheet(req, 'changeset.css')
         add_stylesheet(req, 'diff.css')
-        return 'changeset.cs', None
+        return 'diff.cs', None
 
-    # ITimelineEventProvider methods
 
-    def get_timeline_filters(self, req):
-        if req.perm.has_permission(perm.CHANGESET_VIEW):
-            yield ('changeset', 'Repository checkins')
-
-    def get_timeline_events(self, req, start, stop, filters):
-        if 'changeset' in filters:
-            absurls = req.args.get('format') == 'rss' # Kludge
-            show_files = int(self.config.get('timeline',
-                                             'changeset_show_files'))
-            db = self.env.get_db_cnx()
-            repos = self.env.get_repository()
-            rev = repos.youngest_rev
-            while rev:
-                chgset = repos.get_changeset(rev)
-                if chgset.date < start:
-                    return
-                if chgset.date < stop:
-                    if absurls:
-                        href = self.env.abs_href.changeset(chgset.rev)
-                    else:
-                        href = self.env.href.changeset(chgset.rev)
-                    title = 'Changeset <em>[%s]</em> by %s' % (
-                            util.escape(chgset.rev), util.escape(chgset.author))
-                    message = wiki_to_oneliner(util.shorten_line(chgset.message or '--'),
-                                               self.env, db, absurls=absurls)
-                    if show_files:
-                        files = []
-                        for chg in chgset.get_changes():
-                            if show_files > 0 and len(files) >= show_files:
-                                files.append('...')
-                                break
-                            files.append('<span class="%s">%s</span>'
-                                         % (chg[2], util.escape(chg[0])))
-                        message = '<span class="changes">' + ', '.join(files) +\
-                                  '</span>: ' + message
-                    yield 'changeset', href, title, chgset.date, chgset.author,\
-                          message
-                rev = repos.previous_rev(rev)
-
     # Internal methods
 
-    def _render_html(self, req, repos, chgset, diff_options):
+    def _render_html(self, req, repos, diff, chgset, diff_options):
         """HTML version"""
-        req.hdf['title'] = '[%s]' % chgset.rev
-        req.hdf['changeset'] = {
-            'revision': chgset.rev,
-            'time': time.strftime('%c', time.localtime(chgset.date)),
-            'author': util.escape(chgset.author or 'anonymous'),
-            'message': wiki_to_html(chgset.message or '--', self.env, req,
-                                    escape_newlines=True)
-        }
+        req.hdf['diff'] = diff
+        req.hdf['diff.href'] = {
+            'new_rev': self.env.href.changeset(diff.new_rev),
+            'old_rev': self.env.href.changeset(diff.old_rev),
+            'new_path': self.env.href.browser(diff.new_path, rev=diff.new_rev),
+            'old_path': self.env.href.changeset(diff.old_path, rev=diff.old_rev)
+            }
+        if chgset: # 'path history' mode
+            req.hdf['title'] = 'Changes for %s at Revision %s' % (diff.new_path, chgset.rev)
+            req.hdf['changeset'] = {
+                'revision': chgset.rev,
+                'time': time.strftime('%c', time.localtime(chgset.date)),
+                'author': util.escape(chgset.author or 'anonymous'),
+                'message': wiki_to_html(chgset.message or '--', self.env, req,
+                                        escape_newlines=True)
+                }
 
-        oldest_rev = repos.oldest_rev
-        if chgset.rev != oldest_rev:
-            add_link(req, 'first', self.env.href.changeset(oldest_rev),
-                     'Changeset %s' % oldest_rev)
-            previous_rev = repos.previous_rev(chgset.rev)
-            add_link(req, 'prev', self.env.href.changeset(previous_rev),
-                     'Changeset %s' % previous_rev)
-        youngest_rev = repos.youngest_rev
-        if str(chgset.rev) != str(youngest_rev):
-            next_rev = repos.next_rev(chgset.rev)
-            add_link(req, 'next', self.env.href.changeset(next_rev),
-                     'Changeset %s' % next_rev)
-            add_link(req, 'last', self.env.href.changeset(youngest_rev),
-                     'Changeset %s' % youngest_rev)
+            oldest_rev = repos.oldest_rev
+            if chgset.rev != oldest_rev:
+                add_link(req, 'first', self.env.href.diff(diff.old_path, rev=oldest_rev),
+                         'Changeset %s' % oldest_rev) # FIXME (use the history)
+                previous_rev = repos.previous_rev(chgset.rev)
+                add_link(req, 'prev', self.env.href.diff(diff.old_path, rev=previous_rev),
+                         'Changeset %s' % previous_rev)
+            youngest_rev = repos.youngest_rev
+            if str(chgset.rev) != str(youngest_rev):
+                next_rev = repos.next_rev(chgset.rev)
+                add_link(req, 'next', self.env.href.diff(diff.new_path, rev=next_rev),
+                         'Changeset %s' % next_rev)
+                add_link(req, 'last', self.env.href.diff(diff.new_path, rev=youngest_rev),
+                         'Changeset %s' % youngest_rev)
+        elif diff.new_path == diff.old_path: # 'diff between 2 revisions' mode
+            req.hdf['title'] = 'Diff for %s between Revisions %s and %s' \
+                               % (diff.new_path, diff.old_rev, diff.new_rev)
+        else:                           # 'arbitrary diff' mode
+            req.hdf['title'] = 'Diff between %s at Revision %s and %s at Revision %s' \
+                               % (diff.old_path, diff.old_rev,
+                                  diff.new_path, diff.new_rev)
 
+        ## FIXME: move the get_diff at the level of the repos
+        try:
+            old_root_node = repos.get_node(diff.old_path, diff.old_rev)
+        except TracError:
+            old_root_node = None
+        try:
+            new_root_node = repos.get_node(diff.new_path, diff.new_rev)
+        except TracError:
+            new_root_node = None
+
+        if not old_root_node and not new_root_node:
+            raise TracError, 'Invalid diff request' # FIXME be more explicit
+        elif not old_root_node:
+            raise TracError, 'Unsupported diff request' # FIXME: add everything
+        elif not new_root_node:
+            raise TracError, 'Unsupported diff request' # FIXME: del everything
+
+        if old_root_node.isdir and new_root_node.isdir:
+            old_base = diff.old_path
+            new_base = diff.new_path
+        elif old_root_node.isfile and new_root_node.isfile:
+            old_base = posixpath.split(diff.old_path)[0]
+            new_base = posixpath.split(diff.new_path)[0]
+        else:
+            raise TracError, "Trying to diff a %s with a %s." \
+                  % (old_root_node.kind, new_root_node.kind)
         edits = []
         idx = 0
-        for path, kind, change, base_path, base_rev in chgset.get_changes():
+        for path, kind, change in new_root_node.get_diff(old_root_node):
+            old_path = posixpath.join(old_base, path)
+            new_path = posixpath.join(new_base, path)
+            print 'delta %d: %s %s delta from %s@%s to %s@%s' \
+                  % (idx, change, kind, old_path, diff.old_rev, new_path, diff.new_rev)
+            old_node = repos.get_node(old_path, diff.old_rev)
+            new_node = repos.get_node(new_path, diff.new_rev)
             info = {'change': change}
+            base_path = old_path
+            base_rev = diff.old_rev
+            path = new_path
+            rev = diff.new_rev
             if base_path:
                 info['path.old'] = base_path
                 info['rev.old'] = base_rev
@@ -158 +198 @@
                                                                  rev=base_rev)
             if path:
                 info['path.new'] = path
-                info['rev.new'] = chgset.rev
+                info['rev.new'] = rev
                 info['browser_href.new'] = self.env.href.browser(path,
-                                                                 rev=chgset.rev)
-            if change in (Changeset.COPY, Changeset.EDIT, Changeset.MOVE):
-                edits.append((idx, path, kind, base_path, base_rev))
-            req.hdf['changeset.changes.%d' % idx] = info
-            idx += 1
-
-        for idx, path, kind, base_path, base_rev in edits:
-            old_node = repos.get_node(base_path or path, base_rev)
-            new_node = repos.get_node(path, chgset.rev)
-
+                                                                 rev=rev)
+            req.hdf['diff.changes.%d' % idx] = info
+        
             # Property changes
             old_props = old_node.get_properties()
             new_props = new_node.get_properties()
@@ -183 +216 @@
                 for k,v in new_props.items():
                     if not k in old_props:
                         changed_props[k] = {'new': v}
-                req.hdf['changeset.changes.%d.props' % idx] = changed_props
+                req.hdf['diff.changes.%d.props' % idx] = changed_props
 
             if kind == Node.DIRECTORY:
                 continue
 
             # Content changes
             default_charset = self.config.get('trac', 'default_charset')
-            old_content = old_node.get_content().read()
+            old_content = old_node.get_content().read()            
             if mimeview.is_binary(old_content):
                 continue
             charset = mimeview.get_charset(old_node.content_type) or \
@@ -217 +250 @@
                                    ignore_blank_lines='-B' in diff_options[1],
                                    ignore_case='-i' in diff_options[1],
                                    ignore_space_changes='-b' in diff_options[1])
-                req.hdf['changeset.changes.%d.diff' % idx] = changes
+                req.hdf['diff.changes.%d.diff' % idx] = changes
+            idx += 1
 
-    def _render_diff(self, req, repos, chgset, diff_options):
+
+    def _render_diff(self, req, repos, chgset, diff_options): # TODO
         """Raw Unified Diff version"""
         req.send_response(200)
         req.send_header('Content-Type', 'text/plain;charset=utf-8')
@@ -284 +319 @@
                                          ignore_space_changes='-b' in diff_options[1]):
                     req.write(line + util.CRLF)
 
-    def _render_zip(self, req, repos, chgset):
+    def _render_zip(self, req, repos, chgset): # TODO
         """ZIP archive with all the added and/or modified files."""
         req.send_response(200)
         req.send_header('Content-Type', 'application/zip')

trac/Browser.py

@@ -118 +118 @@
             'props': dict([(util.escape(name), util.escape(value))
                            for name, value in node.get_properties().items()]),
             'href': self.env.href.browser(path,rev=rev or repos.youngest_rev),
+            'diff_href': self.env.href.diff(path,rev=rev or repos.youngest_rev),
             'log_href': self.env.href.log(path)
         }
 
@@ -268 +269 @@
         stop_rev = req.args.get('stop_rev')
         verbose = req.args.get('verbose')
         limit = int(req.args.get('limit') or 100)
+        diff = req.args.get('diff')
+        old = req.args.get('old')
+        new = req.args.get('new')
 
+        repos = self.env.get_repository(req.authname)
+        normpath = repos.normalize_path(path)
+        rev = str(repos.normalize_rev(rev))
+        old = old or str(repos.previous_rev(rev))
+        new = new or rev
+
         req.hdf['title'] = path + ' (log)'
         req.hdf['log'] = {
             'path': path,
@@ -276 +286 @@
             'verbose': verbose,
             'stop_rev': stop_rev,
             'browser_href': self.env.href.browser(path, rev=rev),
-            'log_href': self.env.href.log(path, rev=rev)
+            'log_href': self.env.href.log(path, rev=rev),
+            'select_diff_href': self.env.href.log(path, rev=rev, diff=1),
+            'diff': diff,
+            'diff_href': self.env.href.diff(path, old=old, new=new),
+            'old': old,
+            'new': new
         }
 
         path_links = _get_path_links(self.env.href, path, rev)
@@ -284 +299 @@
         if path_links:
             add_link(req, 'up', path_links[-1]['href'], 'Parent directory')
 
-        repos = self.env.get_repository(req.authname)
-        normpath = repos.normalize_path(path)
-        rev = str(repos.normalize_rev(rev))
-
         # 'node' or 'path' history: use get_node()/get_history() or get_path_history()
         if mode != 'path_history':
             try:

templates/log.cs

@@ -2 +2 @@
 <?cs include "macros.cs"?>
 
 <div id="ctxtnav" class="nav">
- <ul>
-  <li class="last"><a href="<?cs
-    var:log.browser_href ?>">View Latest Revision</a></li><?cs
+ <ul><?cs 
+  if:!log.diff ?>
+   <li class="first">
+    <a href="<?cs var:log.select_diff_href ?>">Select for Diff</a>
+   </li><?cs
+  /if ?>
+  <li class="last">
+   <a href="<?cs var:log.browser_href ?>">View Latest Revision</a>
+  </li><?cs
   if:len(chrome.links.prev) ?>
    <li class="first<?cs if:!len(chrome.links.next) ?> last<?cs /if ?>">
     &larr; <a href="<?cs var:chrome.links.prev.0.href ?>" title="<?cs
@@ -74 +80 @@
    </dl>
   </div>
  </div>
- <table id="chglist" class="listing">
-  <thead>
-   <tr>
+ <table id="chglist" class="listing"><?cs
+   if:log.diff ?>
+    <form action="<?cs var:log.diff_href ?>" method="get"><?cs
+   /if ?>
+  <thead><?cs
+   if:log.diff ?>
+    <tr>
+     <th colspan="2">
+      <div class="buttons">
+       <input type="submit" id="diff" value="Diff" 
+        title="Diff from Old Revision to New Revision (select them below)" />
+      </div>
+     </th>
+    </tr><?cs
+   /if ?>
+   <tr><?cs 
+    if:log.diff ?>
+     <th>Old</th>
+     <th>New</th><?cs
+    /if ?>
     <th class="change"></th>
     <th class="data">Date</th>
     <th class="rev">Rev</th>
@@ -98 +121 @@
     elif:log.mode == "path_history" ?><?cs
       set:indent = #1 ?><?cs
     /if ?>
-    <tr class="<?cs if:name(item) % #2 ?>even<?cs else ?>odd<?cs /if ?>">
+    <tr class="<?cs if:name(item) % #2 ?>even<?cs else ?>odd<?cs /if ?>"><?cs
+     if:log.diff ?>
+     <td><input type="radio" name="old" value="<?cs var:item.rev ?>" <?cs
+          if:item.rev == #log.old ?> checked="checked" <?cs /if ?> /></td>
+     <td><input type="radio" name="new" value="<?cs var:item.rev ?>" <?cs
+          if:item.rev == #log.new ?> checked="checked" <?cs /if ?> /></td><?cs
+     /if ?>
      <td class="change" style="padding-left:<?cs var:indent ?>em">
       <a title="View log starting at this revision" href="<?cs var:item.log_href ?>">
        <div class="<?cs var:item.change ?>"></div>
@@ -116 +145 @@
      <td class="summary"><?cs var:log.changes[item.rev].message ?></td>
     </tr><?cs
    /each ?>
-  </tbody>
+  </tbody><?cs
+   if:log.diff ?>
+    </form><?cs
+   /if ?>
  </table><?cs
  if:len(links.prev) || len(links.next) ?><div id="paging" class="nav"><ul><?cs
   if:len(links.prev) ?><li class="first<?cs

templates/browser.cs

@@ -3 +3 @@
 
 <div id="ctxtnav" class="nav">
  <ul>
+  <li class="first"><a href="<?cs var:browser.diff_href ?>">Diff to previous</a></li>
   <li class="last"><a href="<?cs var:browser.log_href ?>">Revision Log</a></li>
  </ul>
 </div>

templates/diff.cs

@@ -2 +2 @@
 <?cs include "macros.cs"?>
 
 <div id="ctxtnav" class="nav">
- <h2>Changeset Navigation</h2><?cs
+ <h2>Diff Navigation</h2><?cs
  with:links = chrome.links ?>
   <ul><?cs
    if:len(links.prev) ?>
     <li class="first<?cs if:!len(links.next) ?> last<?cs /if ?>">
      <a class="prev" href="<?cs var:links.prev.0.href ?>" title="<?cs
-       var:links.prev.0.title ?>">Previous Changeset</a>
+       var:links.prev.0.title ?>">Previous Diff</a>
     </li><?cs
    /if ?><?cs
    if:len(links.next) ?>
     <li class="<?cs if:len(links.prev) ?>first <?cs /if ?>last">
      <a class="next" href="<?cs var:links.next.0.href ?>" title="<?cs
-       var:links.next.0.title ?>">Next Changeset</a>
+       var:links.next.0.title ?>">Next Diff</a>
     </li><?cs
    /if ?>
   </ul><?cs
@@ -22 +22 @@
 </div>
 
 <div id="content" class="changeset">
-<h1>Changeset <?cs var:changeset.revision ?></h1>
+<h1><?cs
+ if:len(changeset) > #0 ?>
+  Changes for <a title="Show entry in browser" href="<?cs var:diff.href.new_path ?>">
+   <?cs var:diff.new_path ?></a> 
+  in Revision <a title="Show full changeset" href="<?cs var:diff.href.new_rev ?>">
+   <?cs var:diff.new_rev ?></a><?cs
+ elif:diff.new_path == diff.old_path ?>
+  Differences for <a title="Show entry in browser" href="<?cs var:diff.href.new_path ?>">
+   <?cs var:diff.new_path ?></a> 
+  between Revisions <a title="Show full changeset" href="<?cs var:diff.href.old_rev ?>">
+   <?cs var:diff.old_rev ?></a>
+  and <a title="Show full changese