Upgrade to coverage 3.7.1 and have it auto-build itself on first use.

third_party/coverage-3.7.1/coverage/html.py

 """HTML reporting for Coverage."""
 
 import os, re, shutil, sys
 
 import coverage
 from coverage.backward import pickle
 from coverage.misc import CoverageException, Hasher
 from coverage.phystokens import source_token_lines, source_encoding
 from coverage.report import Reporter
 from coverage.results import Numbers
 from coverage.templite import Templite
 
-# Disable pylint msg W0612, because a bunch of variables look unused, but
-# they're accessed in a Templite context via locals().
-# pylint: disable=W0612
 
-def data_filename(fname):
-    """Return the path to a data file of ours."""
-    return os.path.join(os.path.split(__file__)[0], fname)
+# Static files are looked for in a list of places.
+STATIC_PATH = [
+    # The place Debian puts system Javascript libraries.
+    "/usr/share/javascript",
+
+    # Our htmlfiles directory.
+    os.path.join(os.path.dirname(__file__), "htmlfiles"),
+]
+
+def data_filename(fname, pkgdir=""):
+    """Return the path to a data file of ours.
+
+    The file is searched for on `STATIC_PATH`, and the first place it's found,
+    is returned.
+
+    Each directory in `STATIC_PATH` is searched as-is, and also, if `pkgdir`
+    is provided, at that subdirectory.
+
+    """
+    for static_dir in STATIC_PATH:
+        static_filename = os.path.join(static_dir, fname)
+        if os.path.exists(static_filename):
+            return static_filename
+        if pkgdir:
+            static_filename = os.path.join(static_dir, pkgdir, fname)
+            if os.path.exists(static_filename):
+                return static_filename
+    raise CoverageException("Couldn't find static file %r" % fname)
+
 
 def data(fname):
     """Return the contents of a data file of ours."""
     data_file = open(data_filename(fname))
     try:
         return data_file.read()
     finally:
         data_file.close()
 
 
 class HtmlReporter(Reporter):
     """HTML reporting."""
 
     # These files will be copied from the htmlfiles dir to the output dir.
     STATIC_FILES = [
-            "style.css",
-            "jquery-1.4.3.min.js",
-            "jquery.hotkeys.js",
-            "jquery.isonscreen.js",
-            "jquery.tablesorter.min.js",
-            "coverage_html.js",
-            "keybd_closed.png",
-            "keybd_open.png",
+            ("style.css", ""),
+            ("jquery.min.js", "jquery"),
+            ("jquery.hotkeys.js", "jquery-hotkeys"),
+            ("jquery.isonscreen.js", "jquery-isonscreen"),
+            ("jquery.tablesorter.min.js", "jquery-tablesorter"),
+            ("coverage_html.js", ""),
+            ("keybd_closed.png", ""),
+            ("keybd_open.png", ""),
             ]
 
     def __init__(self, cov, config):
         super(HtmlReporter, self).__init__(cov, config)
         self.directory = None
         self.template_globals = {
             'escape': escape,
             'title': self.config.html_title,
             '__url__': coverage.__url__,
             '__version__': coverage.__version__,
             }
         self.source_tmpl = Templite(
-            data("htmlfiles/pyfile.html"), self.template_globals
+            data("pyfile.html"), self.template_globals
             )
 
         self.coverage = cov
 
         self.files = []
         self.arcs = self.coverage.data.has_arcs()
         self.status = HtmlStatus()
         self.extra_css = None
         self.totals = Numbers()
 
@@ skipping 29 matching lines @@
         # Write the index file.
         self.index_file()
 
         self.make_local_static_report_files()
 
         return self.totals.pc_covered
 
     def make_local_static_report_files(self):
         """Make local instances of static files for HTML report."""
         # The files we provide must always be copied.
-        for static in self.STATIC_FILES:
+        for static, pkgdir in self.STATIC_FILES:
             shutil.copyfile(
-                data_filename("htmlfiles/" + static),
+                data_filename(static, pkgdir),
                 os.path.join(self.directory, static)
                 )
 
         # The user may have extra CSS they want copied.
         if self.extra_css:
             shutil.copyfile(
                 self.config.extra_css,
                 os.path.join(self.directory, self.extra_css)
                 )
 
@@ skipping 36 matching lines @@
         if sys.version_info < (3, 0):
             encoding = source_encoding(source)
             # Some UTF8 files have the dreaded UTF8 BOM. If so, junk it.
             if encoding.startswith("utf-8") and source[:3] == "\xef\xbb\xbf":
                 source = source[3:]
                 encoding = "utf-8"
 
         # Get the numbers for this file.
         nums = analysis.numbers
 
-        missing_branch_arcs = analysis.missing_branch_arcs()
-        arcs = self.arcs
+        if self.arcs:
+            missing_branch_arcs = analysis.missing_branch_arcs()
 
         # These classes determine which lines are highlighted by default.
         c_run = "run hide_run"
         c_exc = "exc"
         c_mis = "mis"
         c_par = "par " + c_run
 
         lines = []
 
         for lineno, line in enumerate(source_token_lines(source)):
@@ skipping 37 matching lines @@
 
             lines.append({
                 'html': ''.join(html),
                 'number': lineno,
                 'class': ' '.join(line_class) or "pln",
                 'annotate': annotate_html,
                 'annotate_title': annotate_title,
             })
 
         # Write the HTML page for this file.
+        html = spaceless(self.source_tmpl.render({
+            'c_exc': c_exc, 'c_mis': c_mis, 'c_par': c_par, 'c_run': c_run,
+            'arcs': self.arcs, 'extra_css': self.extra_css,
+            'cu': cu, 'nums': nums, 'lines': lines,
+        }))
+
+        if sys.version_info < (3, 0):
+            html = html.decode(encoding)
+
         html_filename = flat_rootname + ".html"
         html_path = os.path.join(self.directory, html_filename)
-        extra_css = self.extra_css
-
-        html = spaceless(self.source_tmpl.render(locals()))
-        if sys.version_info < (3, 0):
-            html = html.decode(encoding)
         self.write_html(html_path, html)
 
         # Save this file's information for the index file.
         index_info = {
             'nums': nums,
             'html_filename': html_filename,
             'name': cu.name,
             }
         self.files.append(index_info)
         self.status.set_index_info(flat_rootname, index_info)
 
     def index_file(self):
         """Write the index.html file for this report."""
         index_tmpl = Templite(
-            data("htmlfiles/index.html"), self.template_globals
+            data("index.html"), self.template_globals
             )
 
-        files = self.files
-        arcs = self.arcs
+        self.totals = sum([f['nums'] for f in self.files])
 
-        self.totals = totals = sum([f['nums'] for f in files])
-        extra_css = self.extra_css
+        html = index_tmpl.render({
+            'arcs': self.arcs,
+            'extra_css': self.extra_css,
+            'files': self.files,
+            'totals': self.totals,
+        })
 
-        html = index_tmpl.render(locals())
         if sys.version_info < (3, 0):
             html = html.decode("utf-8")
         self.write_html(
             os.path.join(self.directory, "index.html"),
             html
             )
 
         # Write the latest hashes for next time.
         self.status.write(self.directory)
 
@@ skipping 94 matching lines @@
 
 def spaceless(html):
     """Squeeze out some annoying extra space from an HTML string.
 
     Nicely-formatted templates mean lots of extra space in the result.
     Get rid of some.
 
     """
     html = re.sub(r">\s+<p ", ">\n<p ", html)
     return html