Ticket #5821: wiki-blame-r5892.diff

trac/htdocs/css/wiki.css

@@ -42 +42 @@
 .wiki-toc ul ul, .wiki-toc ol ol { padding-left: 1.2em }
 .wiki-toc li { margin: 0; padding: 0 }
 .wiki-toc .active { background: #ff9; position: relative; }
+
+.blame_wiki { width: 5em; }

trac/templates/macros.html

@@ -56 +56 @@
   -
   -     `label` the label to use after the Previous/Next words
   -     `uplabel` the label to use for the Up link
+  -     `others` a list of any other links you need to appear
   -
   -     Assume the 'chrome' datastructure to be available from the context.
   -->
-  <ul py:def="prevnext_nav(label, uplabel=None)" py:with="links = chrome.links"
+  <ul py:def="prevnext_nav(label, uplabel=None, others=None)" py:with="links = chrome.links"
       py:if="'up' in chrome.links or
              'prev' in chrome.links or
              'next' in chrome.links">
@@ -73 +74 @@
       <a py:with="link = links.up[0]" href="${link.href}"
          title="${link.title}">$uplabel</a>
     </li>
+    <li py:for="a in others">
+      ${a}
+    </li>
     <li class="last" py:choose="">
       <a py:when="'next' in links"  py:with="link = links.next[0]"
          class="next" href="${link.href}"

trac/wiki/web_ui.py

@@ -27 +27 @@
 from trac.attachment import AttachmentModule
 from trac.context import Context, ResourceSystem, ResourceNotFound
 from trac.core import *
-from trac.mimeview.api import Mimeview, IContentConverter
+from trac.mimeview.api import Mimeview, IContentConverter, \
+    is_binary, IHTMLPreviewAnnotator
 from trac.perm import IPermissionRequestor
 from trac.search import ISearchSource, search_to_sql, shorten_result
 from trac.timeline.api import ITimelineEventProvider, TimelineEvent
@@ -51 +52 @@
 
     implements(IContentConverter, INavigationContributor, IPermissionRequestor,
                IRequestHandler, ITimelineEventProvider, ISearchSource,
-               ITemplateProvider)
+               ITemplateProvider, IHTMLPreviewAnnotator)
 
     page_manipulators = ExtensionPoint(IWikiPageManipulator)
 
@@ -531 +532 @@
             'attachments': AttachmentModule(self.env).attachment_list(context),
             'default_template': self.DEFAULT_PAGE_TEMPLATE,
             'templates': templates,
-            'version': version
+            'version': version,
+            'annotate_links': [tag.a(href=req.href.wiki(page.name,
+                version=page.version, annotate='1'))("Annotate")],
         })
+
+        if 'annotate' in req.args:
+            annotations = ['lineno', 'blame_wiki']
+            context.latest_page = page # XXX hack
+            data['preview'] = Mimeview(self.env).preview_data(context,
+                page.text, len(page.text),
+                'text/x-trac-wiki', page.name, '??',
+                annotations=annotations, force_source=True)
+            data['annotate_links'] = [tag.a(href=req.href.wiki(page.name,
+                version=page.version))("Normal")]
+        data['tag'] = tag
         return 'wiki_view.html', data, None
 
     # ITimelineEventProvider methods
@@ -598 +612 @@
                 yield (req.href.wiki(name), '%s: %s' % (name, shorten_line(text)),
                        datetime.fromtimestamp(ts, utc), author,
                        shorten_result(text, terms))
+    def get_annotation_type(self):
+        return 'blame_wiki', 'Version', 'Version in which the line changed'
+
+    def get_annotation_data(self, context):
+        annotations = context.latest_page.get_annotations()
+        #FIXME: use set
+        ages = {}
+        #FIXME: use ages.
+        return (ages, annotations)
+
+    def annotate_row(self, context, row, lineno, line, data):
+        ages, linedata = data
+        row.append(tag.th(tag.a('@', linedata[lineno-1],
+href=context.href.wiki(context.latest_page.name, version=linedata[lineno-1])), class_='blame'))

trac/wiki/model.py

@@ -22 +22 @@
 from trac.core import *
 from trac.util.datefmt import utc, to_timestamp
 from trac.util.translation import _
+from trac.util.blame import LineBlame
 from trac.wiki.api import WikiSystem
 
-
 class WikiPage(object):
     """Represents a wiki page (new or existing)."""
 
@@ -163 +163 @@
         for version,ts,author,comment,ipnr in cursor:
             time = datetime.fromtimestamp(ts, utc)
             yield version,time,author,comment,ipnr
+
+    # Future IBlame?
+    def get_annotations(self, db=None):
+        # we don't want to allow options, just want opcodes.
+        from difflib import SequenceMatcher
+
+        if not db:
+            db = self.env.get_db_cnx()
+        cursor = db.cursor()
+        cursor.execute("SELECT version, time, author, comment, text FROM wiki "
+                       "WHERE name=%s AND version <=%s "
+                       "ORDER BY version", (self.name, self.version))
+        b = LineBlame()
+        for version, ts, author, comment, text in cursor:
+            b.add(version, text.splitlines())
+        return b.revs #FIXME: also return some info about authors, time, etc.
+

trac/wiki/templates/wiki_view.html

@@ -21 +21 @@
       <h2>Wiki Navigation</h2>
       <py:choose>
         <py:when test="version">
-          ${prevnext_nav('Version', 'View Latest Version')}
+          ${prevnext_nav('Version', 'View Latest Version',
+[tag.a(href=href.wiki(page.name, version=context.req.args.version,
+annotate='1'))("Annotate")])}
         </py:when>
         <ul py:otherwise="">
           <li><a href="${href.wiki('WikiStart')}">Start Page</a></li>
           <li><a href="${href.wiki('TitleIndex')}">Index</a></li>
           <li><a href="${href.wiki(page.name, action='history')}">History</a></li>
+          <li py:if="'annotate' not in context.req.args"><a href="${href.wiki(page.name,
+              annotate='1')}">Annotate</a></li>
+          <li py:if="'annotate' in context.req.args"><a
+href="${href.wiki(page.name)}">Normal</a></li>
           <li class="last">
             <a href="${req.href.wiki(page.name, action='diff', version=page.version)}">Last Change</a>
           </li>
@@ -52 +58 @@
 
       <div class="wikipage searchable" py:choose="" xml:space="preserve">
         <py:when test="page.exists" xml:space="preserve">
-          ${wiki_to_html(context, page.text)}
+          <py:if test="not preview">
+            ${wiki_to_html(context, page.text)}
+          </py:if>
+          <div py:if="preview" class="searchable">
+            ${preview_file(preview)}
+          </div>
         </py:when>
         <py:otherwise>
           Describe ${page.name} here.

trac/util/blame.py

@@ +1 @@
+"""
+Provide annotations for source code.  Also known as a blame or praise report.
+
+Extracted from http://timhatch.com/projects/pyannotate/
+"""
+
+from difflib import SequenceMatcher
+
+import sys
+
+__author__ = "Tim Hatch <tim@timhatch.com>"
+__copyright__ = "Copyright (c) 2006 Tim Hatch"
+__license__ = "BSD"
+__all__ = ["Blame", "TokenBlame", "LineBlame", "BackwardsTokenBlame", "BackwardsLineBlame"]
+
+class Blame(object):
+    def show_info(self, data=None):
+        if data is None: data = self.data
+        for rev, line in zip(self.revs, data):
+            print "%8s %s" % (rev, line)
+        if len(self.revs) != len(data):
+            print >>sys.stderr, "Warning: not equal length in show_info", len(self.revs), len(data)
+
+class TokenBlame(Blame):
+    """
+    A basic blame, starting from the beginning and working forward.
+    Must process all revisions in order to arrive at an answer.
+    
+    Feed it diff tokens!
+    """
+    def __init__(self):
+        self.oldest_rev = None
+        self.newest_rev = None
+        self.revs = []
+    def set_size(self, rev, l):
+        """
+        Used for setting the initial revision of a file for future comparison.
+
+        Eventually this will not be required, as the max(i2) of the first diff
+        passed in tells us how long the file is (as long as it knows the 'prev'
+        rev.
+        """
+        self.oldest_rev = rev
+        self.newest_rev = rev
+        self.revs = [rev] * l
+    def add(self, rev, tokens):
+        if self.oldest_rev is None:
+            self.oldest_rev = rev
+
+        # Process data.
+        r = self.revs
+        for tag, i1, i2, j1, j2 in tokens:
+            if tag == "insert":
+                r[j1:j1] = [rev] * (j2-j1)
+            elif tag == "replace":
+                r[j1:j1+(i2-i1)] = [rev] * (j2-j1)
+            elif tag == "delete":
+                del r[j1:j1+(i2-i1)]
+            #FIXME: if we had to set oldest_rev, add the equal blocks too,
+            # but we don't know what rev they belong to.
+
+        self.newest_rev = rev
+
+class BackwardsTokenBlame(Blame):
+    """
+    A basic blame, starting from the end and working backward.
+    Only needs to process lines as long as there are changes left to be found.
+
+    Feed it diff tokens!
+
+    I was toying with 'rev' being the left one.
+    """
+    def __init__(self):
+        Blame.__init__(self)
+        self.oldest_rev = None
+        self.newest_rev = None
+        self.revs = []
+        
+    def set_size(self, rev, l):
+        """
+        Used for setting the initial revision of a file for future comparison.
+
+        Eventually this will not be required, as the max(i2) of the first diff
+        passed in tells us how long the file is (as long as it knows the 'prev'
+        rev.
+        """
+        self.oldest_rev = rev
+        self.newest_rev = rev
+        self.revs = [-1] * l
+        self.offsets = dict(zip(range(l), [0] * l))
+        self.b_rev = rev
+
+    def add(self, rev, tokens):
+        """
+        This is perhaps different because 'rev' is the one which causes the
+        change.  For a->b working backward, feed tokens normally but pass
+        a's rev.  For a<-b working forward, pass b's rev.
+        """
+        if self.newest_rev is None:
+            self.newest_rev = rev
+
+        newoffsets = {}
+        o = self.offsets
+        for tag, i1, i2, j1, j2 in tokens:
+            if tag == "delete":
+                # We don't need to go back further, these lines have no
+                # further lineage.
+                pass
+            elif tag == "insert" or tag == "replace":
+                # These lines are touched in this rev, so don't go back
+                # further.
+                x = j1-i1
+                # Mark them as sourced by this rev.
+                for j in range(j1, j2):
+                    if j in o: # and o[j] != -1:
+                        self.revs[j - o[j]] = self.b_rev
+            elif tag == "equal":
+                # These _do_ go back further, so update their offsets.
+                x = j1-i1
+                for i in range(i1, i2):
+                    if (i+x) in o: # and self.offsets[i+x] != -1:
+                        newoffsets[i] = o[i+x] - x
+
+        self.offsets = newoffsets
+        self.oldest_rev = rev
+        self.b_rev = rev
+
+        if not len(self.offsets): raise StopIteration()
+
+class LineBlame(TokenBlame):
+    """
+    Feed me lines!
+    """
+    def __init__(self):
+        TokenBlame.__init__(self)
+        self.data = None
+    def add(self, rev, lines):
+        if self.oldest_rev is None:
+            self.set_size(rev, len(lines))
+        else:
+            s = SequenceMatcher(None, self.data, lines)
+            TokenBlame.add(self, rev, s.get_opcodes())
+        self.data = lines
+
+class BackwardsLineBlame(BackwardsTokenBlame):
+    """
+    Feed me lines!  Backwards!
+    """
+    def __init__(self):
+        BackwardsTokenBlame.__init__(self)
+        self.data = None
+    def add(self, rev, lines):
+        if self.oldest_rev is None:
+            self.set_size(rev, len(lines))
+            self.data = lines
+            self.prev_data = lines
+        else:
+            s = SequenceMatcher(None, lines, self.prev_data)
+            #codes = list(s.get_opcodes())
+            #print "\n", rev, self.prev_data, lines
+            #print codes
+            BackwardsTokenBlame.add(self, rev, s.get_opcodes())
+        self.prev_data = lines
+