Merge lp:~mitya57/ubuntu/trusty/python-coverage/merge-rc-bugfix into lp:ubuntu/trusty/python-coverage

[Dmitry Shachnev]

This is a merge from Debian.

Upstream changes: new bugfix release.
Debian changes: fixes an RC bug (#740053) and another packaging bug (#736121).

[lp:~mitya57/ubuntu/trusty/python-coverage/merge-rc-bugfix]

15. By Dmitry Shachnev on 2014-03-07

Merge with Debian unstable, remaining change:
- Add python3-coverage.preinst to correctly handle upgrades from
  previous releases.

[Martin Pitt (pitti)]

Thanks! Sponsored.

review: Approve

=== added directory '.pc/02.rename-public-programs.patch'
=== added file '.pc/02.rename-public-programs.patch/setup.py'
--- .pc/02.rename-public-programs.patch/setup.py	1970-01-01 00:00:00 +0000
+++ .pc/02.rename-public-programs.patch/setup.py	2014-03-07 05:33:58 +0000
@@ -0,0 +1,196 @@
+# setup.py for coverage.py
+
+"""Code coverage measurement for Python
+
+Coverage.py measures code coverage, typically during test execution. It uses
+the code analysis tools and tracing hooks provided in the Python standard
+library to determine which lines are executable, and which have been executed.
+
+Coverage.py runs on Pythons 2.3 through 3.3, and PyPy 1.9.
+
+Documentation is at `nedbatchelder.com <%s>`_.  Code repository and issue
+tracker are on `Bitbucket <http://bitbucket.org/ned/coveragepy>`_, with a
+mirrored repo on `Github <https://github.com/nedbat/coveragepy>`_.
+
+New in 3.7: ``--debug``, and 12 bugs closed.
+
+New in 3.6: ``--fail-under``, and >20 bugs closed.
+
+New in 3.5: Branch coverage exclusions, keyboard shortcuts in HTML report.
+
+New in 3.4: Better control over source to measure, and unexecuted files
+can be reported.
+
+New in 3.3: .coveragerc files.
+
+New in 3.2: Branch coverage!
+"""
+
+# This file is used unchanged under all versions of Python, 2.x and 3.x.
+
+classifiers = """\
+Environment :: Console
+Intended Audience :: Developers
+License :: OSI Approved :: BSD License
+Operating System :: OS Independent
+Programming Language :: Python :: 2
+Programming Language :: Python :: 3
+Topic :: Software Development :: Quality Assurance
+Topic :: Software Development :: Testing
+"""
+
+# Pull in the tools we need.
+import os, sys
+
+from setuptools import setup
+from distutils.core import Extension        # pylint: disable=E0611,F0401
+from distutils.command.build_ext import build_ext   # pylint: disable=E0611,F0401,C0301
+from distutils import errors                # pylint: disable=E0611,F0401
+
+# Get or massage our metadata.  We exec coverage/version.py so we can avoid
+# importing the product code into setup.py.
+
+doc = __doc__                   # __doc__ will be overwritten by version.py.
+__version__ = __url__ = ""      # Keep pylint happy.
+
+cov_ver_py = os.path.join(os.path.split(__file__)[0], "coverage/version.py")
+version_file = open(cov_ver_py)
+try:
+    exec(compile(version_file.read(), cov_ver_py, 'exec'))
+finally:
+    version_file.close()
+
+doclines = (doc % __url__).splitlines()
+classifier_list = classifiers.splitlines()
+
+if 'a' in __version__:
+    devstat = "3 - Alpha"
+elif 'b' in __version__:
+    devstat = "4 - Beta"
+else:
+    devstat = "5 - Production/Stable"
+classifier_list.append("Development Status :: " + devstat)
+
+# Install a script as "coverage", and as "coverage[23]", and as
+# "coverage-2.7" (or whatever).
+scripts = [
+    'coverage = coverage:main',
+    'coverage%d = coverage:main' % sys.version_info[:1],
+    'coverage-%d.%d = coverage:main' % sys.version_info[:2],
+    ]
+
+# Create the keyword arguments for setup()
+
+setup_args = dict(
+    name = 'coverage',
+    version = __version__,
+
+    packages = [
+        'coverage',
+        ],
+
+    entry_points = {'console_scripts': scripts},
+
+    # We need to get HTML assets from our htmlfiles dir.
+    zip_safe = False,
+
+    author = 'Ned Batchelder and others',
+    author_email = '[e-mail]',
+    description = doclines[0],
+    long_description = '\n'.join(doclines[2:]),
+    keywords = 'code coverage testing',
+    license = 'BSD',
+    classifiers = classifier_list,
+    url = __url__,
+    )
+
+# A replacement for the build_ext command which raises a single exception
+# if the build fails, so we can fallback nicely.
+
+ext_errors = (
+    errors.CCompilerError,
+    errors.DistutilsExecError,
+    errors.DistutilsPlatformError,
+)
+if sys.platform == 'win32' and sys.version_info > (2, 6):
+    # 2.6's distutils.msvc9compiler can raise an IOError when failing to
+    # find the compiler
+    ext_errors += (IOError,)
+
+class BuildFailed(Exception):
+    """Raise this to indicate the C extension wouldn't build."""
+    def __init__(self):
+        Exception.__init__(self)
+        self.cause = sys.exc_info()[1] # work around py 2/3 different syntax
+
+class ve_build_ext(build_ext):
+    """Build C extensions, but fail with a straightforward exception."""
+
+    def run(self):
+        """Wrap `run` with `BuildFailed`."""
+        try:
+            build_ext.run(self)
+        except errors.DistutilsPlatformError:
+            raise BuildFailed()
+
+    def build_extension(self, ext):
+        """Wrap `build_extension` with `BuildFailed`."""
+        try:
+            # Uncomment to test compile failures:
+            #   raise errors.CCompilerError("OOPS")
+            build_ext.build_extension(self, ext)
+        except ext_errors:
+            raise BuildFailed()
+        except ValueError:
+            # this can happen on Windows 64 bit, see Python issue 7511
+            if "'path'" in str(sys.exc_info()[1]): # works with both py 2/3
+                raise BuildFailed()
+            raise
+
+# There are a few reasons we might not be able to compile the C extension.
+# Figure out if we should attempt the C extension or not.
+
+compile_extension = True
+
+if sys.platform.startswith('java'):
+    # Jython can't compile C extensions
+    compile_extension = False
+
+if '__pypy__' in sys.builtin_module_names:
+    # Pypy can't compile C extensions
+    compile_extension = False
+
+if compile_extension:
+    setup_args.update(dict(
+        ext_modules = [
+            Extension("coverage.tracer", sources=["coverage/tracer.c"])
+            ],
+        cmdclass = {
+            'build_ext': ve_build_ext,
+            },
+        ))
+
+# Py3.x-specific details.
+
+if sys.version_info >= (3, 0):
+    setup_args.update(dict(
+        use_2to3 = False,
+        ))
+
+def main():
+    """Actually invoke setup() with the arguments we built above."""
+    # For a variety of reasons, it might not be possible to install the C
+    # extension.  Try it with, and if it fails, try it without.
+    try:
+        setup(**setup_args)
+    except BuildFailed:
+        msg = "Couldn't install with extension module, trying without it..."
+        exc = sys.exc_info()[1]
+        exc_msg = "%s: %s" % (exc.__class__.__name__, exc.cause)
+        print("**\n** %s\n** %s\n**" % (msg, exc_msg))
+
+        del setup_args['ext_modules']
+        setup(**setup_args)
+
+if __name__ == '__main__':
+    main()

=== removed directory '.pc/02.use-system-ecmascript-libraries.patch'
=== removed directory '.pc/02.use-system-ecmascript-libraries.patch/coverage'
=== removed file '.pc/02.use-system-ecmascript-libraries.patch/coverage/html.py'
--- .pc/02.use-system-ecmascript-libraries.patch/coverage/html.py	2013-10-15 13:16:36 +0000
+++ .pc/02.use-system-ecmascript-libraries.patch/coverage/html.py	1970-01-01 00:00:00 +0000
@@ -1,387 +0,0 @@
-"""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
-
-
-# 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):
-    """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.
-
-    """
-    for static_dir in STATIC_PATH:
-        static_filename = os.path.join(static_dir, 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.min.js",
-            "jquery.hotkeys.js",
-            "jquery.isonscreen.js",
-            "jquery.tablesorter.min.js",
-            "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("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()
-
-    def report(self, morfs):
-        """Generate an HTML report for `morfs`.
-
-        `morfs` is a list of modules or filenames.
-
-        """
-        assert self.config.html_dir, "must give a directory for html reporting"
-
-        # Read the status data.
-        self.status.read(self.config.html_dir)
-
-        # Check that this run used the same settings as the last run.
-        m = Hasher()
-        m.update(self.config)
-        these_settings = m.digest()
-        if self.status.settings_hash() != these_settings:
-            self.status.reset()
-            self.status.set_settings_hash(these_settings)
-
-        # The user may have extra CSS they want copied.
-        if self.config.extra_css:
-            self.extra_css = os.path.basename(self.config.extra_css)
-
-        # Process all the files.
-        self.report_files(self.html_file, morfs, self.config.html_dir)
-
-        if not self.files:
-            raise CoverageException("No data to report.")
-
-        # 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:
-            shutil.copyfile(
-                data_filename(static),
-                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)
-                )
-
-    def write_html(self, fname, html):
-        """Write `html` to `fname`, properly encoded."""
-        fout = open(fname, "wb")
-        try:
-            fout.write(html.encode('ascii', 'xmlcharrefreplace'))
-        finally:
-            fout.close()
-
-    def file_hash(self, source, cu):
-        """Compute a hash that changes if the file needs to be re-reported."""
-        m = Hasher()
-        m.update(source)
-        self.coverage.data.add_to_hash(cu.filename, m)
-        return m.digest()
-
-    def html_file(self, cu, analysis):
-        """Generate an HTML file for one source file."""
-        source_file = cu.source_file()
-        try:
-            source = source_file.read()
-        finally:
-            source_file.close()
-
-        # Find out if the file on disk is already correct.
-        flat_rootname = cu.flat_rootname()
-        this_hash = self.file_hash(source, cu)
-        that_hash = self.status.file_hash(flat_rootname)
-        if this_hash == that_hash:
-            # Nothing has changed to require the file to be reported again.
-            self.files.append(self.status.index_info(flat_rootname))
-            return
-
-        self.status.set_file_hash(flat_rootname, this_hash)
-
-        # If need be, determine the encoding of the source file. We use it
-        # later to properly write the HTML.
-        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()
-
-        # 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)):
-            lineno += 1     # 1-based line numbers.
-            # Figure out how to mark this line.
-            line_class = []
-            annotate_html = ""
-            annotate_title = ""
-            if lineno in analysis.statements:
-                line_class.append("stm")
-            if lineno in analysis.excluded:
-                line_class.append(c_exc)
-            elif lineno in analysis.missing:
-                line_class.append(c_mis)
-            elif self.arcs and lineno in missing_branch_arcs:
-                line_class.append(c_par)
-                annlines = []
-                for b in missing_branch_arcs[lineno]:
-                    if b < 0:
-                        annlines.append("exit")
-                    else:
-                        annlines.append(str(b))
-                annotate_html = "&nbsp;&nbsp; ".join(annlines)
-                if len(annlines) > 1:
-                    annotate_title = "no jumps to these line numbers"
-                elif len(annlines) == 1:
-                    annotate_title = "no jump to this line number"
-            elif lineno in analysis.statements:
-                line_class.append(c_run)
-
-            # Build the HTML for the line
-            html = []
-            for tok_type, tok_text in line:
-                if tok_type == "ws":
-                    html.append(escape(tok_text))
-                else:
-                    tok_html = escape(tok_text) or '&nbsp;'
-                    html.append(
-                        "<span class='%s'>%s</span>" % (tok_type, tok_html)
-                        )
-
-            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)
-        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("index.html"), self.template_globals
-            )
-
-        self.totals = sum([f['nums'] for f in self.files])
-
-        html = index_tmpl.render({
-            'arcs': self.arcs,
-            'extra_css': self.extra_css,
-            'files': self.files,
-            'totals': self.totals,
-        })
-
-        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)
-
-
-class HtmlStatus(object):
-    """The status information we keep to support incremental reporting."""
-
-    STATUS_FILE = "status.dat"
-    STATUS_FORMAT = 1
-
-    def __init__(self):
-        self.reset()
-
-    def reset(self):
-        """Initialize to empty."""
-        self.settings = ''
-        self.files = {}
-
-    def read(self, directory):
-        """Read the last status in `directory`."""
-        usable = False
-        try:
-            status_file = os.path.join(directory, self.STATUS_FILE)
-            fstatus = open(status_file, "rb")
-            try:
-                status = pickle.load(fstatus)
-            finally:
-                fstatus.close()
-        except (IOError, ValueError):
-            usable = False
-        else:
-            usable = True
-            if status['format'] != self.STATUS_FORMAT:
-                usable = False
-            elif status['version'] != coverage.__version__:
-                usable = False
-
-        if usable:
-            self.files = status['files']
-            self.settings = status['settings']
-        else:
-            self.reset()
-
-    def write(self, directory):
-        """Write the current status to `directory`."""
-        status_file = os.path.join(directory, self.STATUS_FILE)
-        status = {
-            'format': self.STATUS_FORMAT,
-            'version': coverage.__version__,
-            'settings': self.settings,
-            'files': self.files,
-            }
-        fout = open(status_file, "wb")
-        try:
-            pickle.dump(status, fout)
-        finally:
-            fout.close()
-
-    def settings_hash(self):
-        """Get the hash of the coverage.py settings."""
-        return self.settings
-
-    def set_settings_hash(self, settings):
-        """Set the hash of the coverage.py settings."""
-        self.settings = settings
-
-    def file_hash(self, fname):
-        """Get the hash of `fname`'s contents."""
-        return self.files.get(fname, {}).get('hash', '')
-
-    def set_file_hash(self, fname, val):
-        """Set the hash of `fname`'s contents."""
-        self.files.setdefault(fname, {})['hash'] = val
-
-    def index_info(self, fname):
-        """Get the information for index.html for `fname`."""
-        return self.files.get(fname, {}).get('index', {})
-
-    def set_index_info(self, fname, info):
-        """Set the information for index.html for `fname`."""
-        self.files.setdefault(fname, {})['index'] = info
-
-
-# Helpers for templates and generating HTML
-
-def escape(t):
-    """HTML-escape the text in `t`."""
-    return (t
-            # Convert HTML special chars into HTML entities.
-            .replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
-            .replace("'", "&#39;").replace('"', "&quot;")
-            # Convert runs of spaces: "......" -> "&nbsp;.&nbsp;.&nbsp;."
-            .replace("  ", "&nbsp; ")
-            # To deal with odd-length runs, convert the final pair of spaces
-            # so that "....." -> "&nbsp;.&nbsp;&nbsp;."
-            .replace("  ", "&nbsp; ")
-        )
-
-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

=== removed directory '.pc/03.rename-public-programs.patch'
=== removed file '.pc/03.rename-public-programs.patch/setup.py'
--- .pc/03.rename-public-programs.patch/setup.py	2013-10-15 13:16:36 +0000
+++ .pc/03.rename-public-programs.patch/setup.py	1970-01-01 00:00:00 +0000
@@ -1,196 +0,0 @@
-# setup.py for coverage.py
-
-"""Code coverage measurement for Python
-
-Coverage.py measures code coverage, typically during test execution. It uses
-the code analysis tools and tracing hooks provided in the Python standard
-library to determine which lines are executable, and which have been executed.
-
-Coverage.py runs on Pythons 2.3 through 3.3, and PyPy 1.9.
-
-Documentation is at `nedbatchelder.com <%s>`_.  Code repository and issue
-tracker are on `Bitbucket <http://bitbucket.org/ned/coveragepy>`_, with a
-mirrored repo on `Github <https://github.com/nedbat/coveragepy>`_.
-
-New in 3.7: ``--debug``, and 12 bugs closed.
-
-New in 3.6: ``--fail-under``, and >20 bugs closed.
-
-New in 3.5: Branch coverage exclusions, keyboard shortcuts in HTML report.
-
-New in 3.4: Better control over source to measure, and unexecuted files
-can be reported.
-
-New in 3.3: .coveragerc files.
-
-New in 3.2: Branch coverage!
-"""
-
-# This file is used unchanged under all versions of Python, 2.x and 3.x.
-
-classifiers = """\
-Environment :: Console
-Intended Audience :: Developers
-License :: OSI Approved :: BSD License
-Operating System :: OS Independent
-Programming Language :: Python :: 2
-Programming Language :: Python :: 3
-Topic :: Software Development :: Quality Assurance
-Topic :: Software Development :: Testing
-"""
-
-# Pull in the tools we need.
-import os, sys
-
-from setuptools import setup
-from distutils.core import Extension        # pylint: disable=E0611,F0401
-from distutils.command.build_ext import build_ext   # pylint: disable=E0611,F0401,C0301
-from distutils import errors                # pylint: disable=E0611,F0401
-
-# Get or massage our metadata.  We exec coverage/version.py so we can avoid
-# importing the product code into setup.py.
-
-doc = __doc__                   # __doc__ will be overwritten by version.py.
-__version__ = __url__ = ""      # Keep pylint happy.
-
-cov_ver_py = os.path.join(os.path.split(__file__)[0], "coverage/version.py")
-version_file = open(cov_ver_py)
-try:
-    exec(compile(version_file.read(), cov_ver_py, 'exec'))
-finally:
-    version_file.close()
-
-doclines = (doc % __url__).splitlines()
-classifier_list = classifiers.splitlines()
-
-if 'a' in __version__:
-    devstat = "3 - Alpha"
-elif 'b' in __version__:
-    devstat = "4 - Beta"
-else:
-    devstat = "5 - Production/Stable"
-classifier_list.append("Development Status :: " + devstat)
-
-# Install a script as "coverage", and as "coverage[23]", and as
-# "coverage-2.7" (or whatever).
-scripts = [
-    'coverage = coverage:main',
-    'coverage%d = coverage:main' % sys.version_info[:1],
-    'coverage-%d.%d = coverage:main' % sys.version_info[:2],
-    ]
-
-# Create the keyword arguments for setup()
-
-setup_args = dict(
-    name = 'coverage',
-    version = __version__,
-
-    packages = [
-        'coverage',
-        ],
-
-    entry_points = {'console_scripts': scripts},
-
-    # We need to get HTML assets from our htmlfiles dir.
-    zip_safe = False,
-
-    author = 'Ned Batchelder and others',
-    author_email = '[e-mail]',
-    description = doclines[0],
-    long_description = '\n'.join(doclines[2:]),
-    keywords = 'code coverage testing',
-    license = 'BSD',
-    classifiers = classifier_list,
-    url = __url__,
-    )
-
-# A replacement for the build_ext command which raises a single exception
-# if the build fails, so we can fallback nicely.
-
-ext_errors = (
-    errors.CCompilerError,
-    errors.DistutilsExecError,
-    errors.DistutilsPlatformError,
-)
-if sys.platform == 'win32' and sys.version_info > (2, 6):
-    # 2.6's distutils.msvc9compiler can raise an IOError when failing to
-    # find the compiler
-    ext_errors += (IOError,)
-
-class BuildFailed(Exception):
-    """Raise this to indicate the C extension wouldn't build."""
-    def __init__(self):
-        Exception.__init__(self)
-        self.cause = sys.exc_info()[1] # work around py 2/3 different syntax
-
-class ve_build_ext(build_ext):
-    """Build C extensions, but fail with a straightforward exception."""
-
-    def run(self):
-        """Wrap `run` with `BuildFailed`."""
-        try:
-            build_ext.run(self)
-        except errors.DistutilsPlatformError:
-            raise BuildFailed()
-
-    def build_extension(self, ext):
-        """Wrap `build_extension` with `BuildFailed`."""
-        try:
-            # Uncomment to test compile failures:
-            #   raise errors.CCompilerError("OOPS")
-            build_ext.build_extension(self, ext)
-        except ext_errors:
-            raise BuildFailed()
-        except ValueError:
-            # this can happen on Windows 64 bit, see Python issue 7511
-            if "'path'" in str(sys.exc_info()[1]): # works with both py 2/3
-                raise BuildFailed()
-            raise
-
-# There are a few reasons we might not be able to compile the C extension.
-# Figure out if we should attempt the C extension or not.
-
-compile_extension = True
-
-if sys.platform.startswith('java'):
-    # Jython can't compile C extensions
-    compile_extension = False
-
-if '__pypy__' in sys.builtin_module_names:
-    # Pypy can't compile C extensions
-    compile_extension = False
-
-if compile_extension:
-    setup_args.update(dict(
-        ext_modules = [
-            Extension("coverage.tracer", sources=["coverage/tracer.c"])
-            ],
-        cmdclass = {
-            'build_ext': ve_build_ext,
-            },
-        ))
-
-# Py3.x-specific details.
-
-if sys.version_info >= (3, 0):
-    setup_args.update(dict(
-        use_2to3 = False,
-        ))
-
-def main():
-    """Actually invoke setup() with the arguments we built above."""
-    # For a variety of reasons, it might not be possible to install the C
-    # extension.  Try it with, and if it fails, try it without.
-    try:
-        setup(**setup_args)
-    except BuildFailed:
-        msg = "Couldn't install with extension module, trying without it..."
-        exc = sys.exc_info()[1]
-        exc_msg = "%s: %s" % (exc.__class__.__name__, exc.cause)
-        print("**\n** %s\n** %s\n**" % (msg, exc_msg))
-
-        del setup_args['ext_modules']
-        setup(**setup_args)
-
-if __name__ == '__main__':
-    main()

=== modified file '.pc/applied-patches'
--- .pc/applied-patches	2014-01-06 21:48:50 +0000
+++ .pc/applied-patches	2014-03-07 05:33:58 +0000
@@ -1,3 +1,2 @@
 01.omit-resource-files-from-distutils-setup.patch
-02.use-system-ecmascript-libraries.patch
-03.rename-public-programs.patch
+02.rename-public-programs.patch

=== modified file 'CHANGES.txt'
--- CHANGES.txt	2014-01-06 21:48:50 +0000
+++ CHANGES.txt	2014-03-07 05:33:58 +0000
@@ -2,6 +2,15 @@
 Change history for Coverage.py
 ------------------------------
 
+3.7.1 -- 13 December 2013
+-------------------------
+
+- Improved the speed of HTML report generation by about 20%.
+
+- Fixed the mechanism for finding OS-installed static files for the HTML report
+  so that it will actually find OS-installed static files.
+
+
 3.7 --- 6 October 2013
 ----------------------
 

=== modified file 'PKG-INFO'
--- PKG-INFO	2014-01-06 21:48:50 +0000
+++ PKG-INFO	2014-03-07 05:33:58 +0000
@@ -1,6 +1,6 @@
-Metadata-Version: 1.1
+Metadata-Version: 1.0
 Name: coverage
-Version: 3.7
+Version: 3.7.1
 Summary: Code coverage measurement for Python
 Home-page: http://nedbatchelder.com/code/coverage
 Author: Ned Batchelder and others

=== modified file 'coverage.egg-info/PKG-INFO'
--- coverage.egg-info/PKG-INFO	2014-01-06 21:48:50 +0000
+++ coverage.egg-info/PKG-INFO	2014-03-07 05:33:58 +0000
@@ -1,6 +1,6 @@
-Metadata-Version: 1.1
+Metadata-Version: 1.0
 Name: coverage
-Version: 3.7
+Version: 3.7.1
 Summary: Code coverage measurement for Python
 Home-page: http://nedbatchelder.com/code/coverage
 Author: Ned Batchelder and others

=== modified file 'coverage/annotate.py'
--- coverage/annotate.py	2014-01-06 21:48:50 +0000
+++ coverage/annotate.py	2014-03-07 05:33:58 +0000
@@ -2,6 +2,7 @@
 
 import os, re
 
+from coverage.backward import sorted                    # pylint: disable=W0622
 from coverage.report import Reporter
 
 class AnnotateReporter(Reporter):
@@ -59,9 +60,9 @@
             dest_file = filename + ",cover"
         dest = open(dest_file, 'w')
 
-        statements = analysis.statements
-        missing = analysis.missing
-        excluded = analysis.excluded
+        statements = sorted(analysis.statements)
+        missing = sorted(analysis.missing)
+        excluded = sorted(analysis.excluded)
 
         lineno = 0
         i = 0

=== modified file 'coverage/cmdline.py'
--- coverage/cmdline.py	2014-01-06 21:48:50 +0000
+++ coverage/cmdline.py	2014-03-07 05:33:58 +0000
@@ -1,6 +1,6 @@
 """Command-line support for Coverage."""
 
-import optparse, os, sys, traceback
+import optparse, os, sys, time, traceback
 
 from coverage.backward import sorted                # pylint: disable=W0622
 from coverage.execfile import run_python_file, run_python_module
@@ -717,7 +717,11 @@
     if argv is None:
         argv = sys.argv[1:]
     try:
+        start = time.clock()
         status = CoverageScript().command_line(argv)
+        end = time.clock()
+        if 0:
+            print("time: %.3fs" % (end - start))
     except ExceptionDuringRun:
         # An exception was caught while running the product code.  The
         # sys.exc_info() return tuple is packed into an ExceptionDuringRun

=== modified file 'coverage/control.py'
--- coverage/control.py	2014-01-06 21:48:50 +0000
+++ coverage/control.py	2014-03-07 05:33:58 +0000
@@ -572,8 +572,11 @@
         """
         analysis = self._analyze(morf)
         return (
-            analysis.filename, analysis.statements, analysis.excluded,
-            analysis.missing, analysis.missing_formatted()
+            analysis.filename,
+            sorted(analysis.statements),
+            sorted(analysis.excluded),
+            sorted(analysis.missing),
+            analysis.missing_formatted(),
             )
 
     def _analyze(self, it):

=== modified file 'coverage/html.py'
--- coverage/html.py	2014-01-06 21:48:50 +0000
+++ coverage/html.py	2014-03-07 05:33:58 +0000
@@ -20,19 +20,27 @@
     os.path.join(os.path.dirname(__file__), "htmlfiles"),
 ]
 
-def data_filename(fname):
+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))
@@ -47,10 +55,14 @@
 
     # These files will be copied from the htmlfiles dir to the output dir.
     STATIC_FILES = [
-            "style.css",
-            "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):
@@ -113,29 +125,12 @@
     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(static),
+                data_filename(static, pkgdir),
                 os.path.join(self.directory, static)
                 )
 
-        system_javascript_path = os.path.join(
-                os.sep, "usr", "share", "javascript")
-        system_javascript_libraries = {
-                "jquery.min.js":
-                    os.path.join(system_javascript_path, "jquery"),
-                "jquery.hotkeys.js":
-                    os.path.join(system_javascript_path, "jquery-hotkeys"),
-                "jquery.isonscreen.js":
-                    os.path.join(system_javascript_path, "jquery-isonscreen"),
-                "jquery.tablesorter.min.js":
-                    os.path.join(system_javascript_path, "jquery-tablesorter"),
-                }
-        for static, source_dir in system_javascript_libraries.items():
-            shutil.copyfile(
-                    os.path.join(source_dir, static),
-                    os.path.join(self.directory, static))
-
         # The user may have extra CSS they want copied.
         if self.extra_css:
             shutil.copyfile(
@@ -189,7 +184,8 @@
         # Get the numbers for this file.
         nums = analysis.numbers
 
-        missing_branch_arcs = analysis.missing_branch_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"

=== modified file 'coverage/misc.py'
--- coverage/misc.py	2014-01-06 21:48:50 +0000
+++ coverage/misc.py	2014-03-07 05:33:58 +0000
@@ -38,6 +38,8 @@
     i = 0
     j = 0
     start = None
+    statements = sorted(statements)
+    lines = sorted(lines)
     while i < len(statements) and j < len(lines):
         if statements[i] == lines[j]:
             if start == None:
@@ -113,8 +115,10 @@
         self.md5.update(to_bytes(str(type(v))))
         if isinstance(v, string_class):
             self.md5.update(to_bytes(v))
+        elif v is None:
+            pass
         elif isinstance(v, (int, float)):
-            self.update(str(v))
+            self.md5.update(to_bytes(str(v)))
         elif isinstance(v, (tuple, list)):
             for e in v:
                 self.update(e)

=== modified file 'coverage/parser.py'
--- coverage/parser.py	2014-01-06 21:48:50 +0000
+++ coverage/parser.py	2014-03-07 05:33:58 +0000
@@ -108,7 +108,7 @@
         first_line = None
         empty = True
 
-        tokgen = tokenize.generate_tokens(StringIO(self.text).readline)
+        tokgen = generate_tokens(self.text)
         for toktype, ttext, (slineno, _), (elineno, _), ltext in tokgen:
             if self.show_tokens:                # pragma: not covered
                 print("%10s %5s %-20r %r" % (
@@ -175,16 +175,18 @@
             first_line = line
         return first_line
 
-    def first_lines(self, lines, ignore=None):
+    def first_lines(self, lines, *ignores):
         """Map the line numbers in `lines` to the correct first line of the
         statement.
 
-        Skip any line mentioned in `ignore`.
+        Skip any line mentioned in any of the sequences in `ignores`.
 
-        Returns a sorted list of the first lines.
+        Returns a set of the first lines.
 
         """
-        ignore = ignore or []
+        ignore = set()
+        for ign in ignores:
+            ignore.update(ign)
         lset = set()
         for l in lines:
             if l in ignore:
@@ -192,13 +194,13 @@
             new_l = self.first_line(l)
             if new_l not in ignore:
                 lset.add(new_l)
-        return sorted(lset)
+        return lset
 
     def parse_source(self):
         """Parse source text to find executable lines, excluded lines, etc.
 
-        Return values are 1) a sorted list of executable line numbers, and
-        2) a sorted list of excluded line numbers.
+        Return values are 1) a set of executable line numbers, and 2) a set of
+        excluded line numbers.
 
         Reported line numbers are normalized to the first line of multi-line
         statements.
@@ -215,8 +217,11 @@
                 )
 
         excluded_lines = self.first_lines(self.excluded)
-        ignore = excluded_lines + list(self.docstrings)
-        lines = self.first_lines(self.statement_starts, ignore)
+        lines = self.first_lines(
+            self.statement_starts,
+            excluded_lines,
+            self.docstrings
+        )
 
         return lines, excluded_lines
 
@@ -444,14 +449,15 @@
 
         # Get a set of all of the jump-to points.
         jump_to = set()
-        for bc in ByteCodes(self.code.co_code):
+        bytecodes = list(ByteCodes(self.code.co_code))
+        for bc in bytecodes:
             if bc.jump_to >= 0:
                 jump_to.add(bc.jump_to)
 
         chunk_lineno = 0
 
         # Walk the byte codes building chunks.
-        for bc in ByteCodes(self.code.co_code):
+        for bc in bytecodes:
             # Maybe have to start a new chunk
             start_new_chunk = False
             first_chunk = False
@@ -664,3 +670,31 @@
         return "<%d+%d @%d%s %r>" % (
             self.byte, self.length, self.line, bang, list(self.exits)
             )
+
+
+class CachedTokenizer(object):
+    """A one-element cache around tokenize.generate_tokens.
+
+    When reporting, coverage.py tokenizes files twice, once to find the
+    structure of the file, and once to syntax-color it.  Tokenizing is
+    expensive, and easily cached.
+
+    This is a one-element cache so that our twice-in-a-row tokenizing doesn't
+    actually tokenize twice.
+
+    """
+    def __init__(self):
+        self.last_text = None
+        self.last_tokens = None
+
+    def generate_tokens(self, text):
+        """A stand-in for `tokenize.generate_tokens`."""
+        if text != self.last_text:
+            self.last_text = text
+            self.last_tokens = list(
+                tokenize.generate_tokens(StringIO(text).readline)
+            )
+        return self.last_tokens
+
+# Create our generate_tokens cache as a callable replacement function.
+generate_tokens = CachedTokenizer().generate_tokens

=== modified file 'coverage/phystokens.py'
--- coverage/phystokens.py	2014-01-06 21:48:50 +0000
+++ coverage/phystokens.py	2014-03-07 05:33:58 +0000
@@ -1,7 +1,9 @@
 """Better tokenizing for coverage.py."""
 
 import codecs, keyword, re, sys, token, tokenize
-from coverage.backward import StringIO              # pylint: disable=W0622
+from coverage.backward import set                       # pylint: disable=W0622
+from coverage.parser import generate_tokens
+
 
 def phys_tokens(toks):
     """Return all physical tokens, even line continuations.
@@ -18,7 +20,7 @@
     last_ttype = None
     for ttype, ttext, (slineno, scol), (elineno, ecol), ltext in toks:
         if last_lineno != elineno:
-            if last_line and last_line[-2:] == "\\\n":
+            if last_line and last_line.endswith("\\\n"):
                 # We are at the beginning of a new line, and the last line
                 # ended with a backslash.  We probably have to inject a
                 # backslash token into the stream. Unfortunately, there's more
@@ -74,11 +76,11 @@
     is indistinguishable from a final line with a newline.
 
     """
-    ws_tokens = [token.INDENT, token.DEDENT, token.NEWLINE, tokenize.NL]
+    ws_tokens = set([token.INDENT, token.DEDENT, token.NEWLINE, tokenize.NL])
     line = []
     col = 0
     source = source.expandtabs(8).replace('\r\n', '\n')
-    tokgen = tokenize.generate_tokens(StringIO(source).readline)
+    tokgen = generate_tokens(source)
     for ttype, ttext, (_, scol), (_, ecol), _ in phys_tokens(tokgen):
         mark_start = True
         for part in re.split('(\n)', ttext):

=== modified file 'coverage/results.py'
--- coverage/results.py	2014-01-06 21:48:50 +0000
+++ coverage/results.py	2014-03-07 05:33:58 +0000
@@ -26,7 +26,7 @@
         # Identify missing statements.
         executed = self.coverage.data.executed_lines(self.filename)
         exec1 = self.parser.first_lines(executed)
-        self.missing = sorted(set(self.statements) - set(exec1))
+        self.missing = self.statements - exec1
 
         if self.coverage.data.has_arcs():
             self.no_branch = self.parser.lines_matching(

=== modified file 'coverage/templite.py'
--- coverage/templite.py	2011-07-27 16:23:25 +0000
+++ coverage/templite.py	2014-03-07 05:33:58 +0000
@@ -2,7 +2,53 @@
 
 # Coincidentally named the same as http://code.activestate.com/recipes/496702/
 
-import re, sys
+import re
+
+from coverage.backward import set                       # pylint: disable=W0622
+
+
+class CodeBuilder(object):
+    """Build source code conveniently."""
+
+    def __init__(self, indent=0):
+        self.code = []
+        self.indent_amount = indent
+
+    def add_line(self, line):
+        """Add a line of source to the code.
+
+        Don't include indentations or newlines.
+
+        """
+        self.code.append(" " * self.indent_amount)
+        self.code.append(line)
+        self.code.append("\n")
+
+    def add_section(self):
+        """Add a section, a sub-CodeBuilder."""
+        sect = CodeBuilder(self.indent_amount)
+        self.code.append(sect)
+        return sect
+
+    def indent(self):
+        """Increase the current indent for following lines."""
+        self.indent_amount += 4
+
+    def dedent(self):
+        """Decrease the current indent for following lines."""
+        self.indent_amount -= 4
+
+    def __str__(self):
+        return "".join([str(c) for c in self.code])
+
+    def get_function(self, fn_name):
+        """Compile the code, and return the function `fn_name`."""
+        assert self.indent_amount == 0
+        g = {}
+        code_text = str(self)
+        exec(code_text, g)
+        return g[fn_name]
+
 
 class Templite(object):
     """A simple template renderer, for a nano-subset of Django syntax.
@@ -39,53 +85,104 @@
         for context in contexts:
             self.context.update(context)
 
+        # We construct a function in source form, then compile it and hold onto
+        # it, and execute it to render the template.
+        code = CodeBuilder()
+
+        code.add_line("def render(ctx, dot):")
+        code.indent()
+        vars_code = code.add_section()
+        self.all_vars = set()
+        self.loop_vars = set()
+        code.add_line("result = []")
+        code.add_line("a = result.append")
+        code.add_line("e = result.extend")
+        code.add_line("s = str")
+
+        buffered = []
+        def flush_output():
+            """Force `buffered` to the code builder."""
+            if len(buffered) == 1:
+                code.add_line("a(%s)" % buffered[0])
+            elif len(buffered) > 1:
+                code.add_line("e([%s])" % ",".join(buffered))
+            del buffered[:]
+
         # Split the text to form a list of tokens.
         toks = re.split(r"(?s)({{.*?}}|{%.*?%}|{#.*?#})", text)
 
-        # Parse the tokens into a nested list of operations.  Each item in the
-        # list is a tuple with an opcode, and arguments.  They'll be
-        # interpreted by TempliteEngine.
-        #
-        # When parsing an action tag with nested content (if, for), the current
-        # ops list is pushed onto ops_stack, and the parsing continues in a new
-        # ops list that is part of the arguments to the if or for op.
-        ops = []
         ops_stack = []
         for tok in toks:
             if tok.startswith('{{'):
-                # Expression: ('exp', expr)
-                ops.append(('exp', tok[2:-2].strip()))
+                # An expression to evaluate.
+                buffered.append("s(%s)" % self.expr_code(tok[2:-2].strip()))
             elif tok.startswith('{#'):
                 # Comment: ignore it and move on.
                 continue
             elif tok.startswith('{%'):
                 # Action tag: split into words and parse further.
+                flush_output()
                 words = tok[2:-2].strip().split()
                 if words[0] == 'if':
-                    # If: ('if', (expr, body_ops))
-                    if_ops = []
+                    # An if statement: evaluate the expression to determine if.
                     assert len(words) == 2
-                    ops.append(('if', (words[1], if_ops)))
-                    ops_stack.append(ops)
-                    ops = if_ops
+                    ops_stack.append('if')
+                    code.add_line("if %s:" % self.expr_code(words[1]))
+                    code.indent()
                 elif words[0] == 'for':
-                    # For: ('for', (varname, listexpr, body_ops))
+                    # A loop: iterate over expression result.
                     assert len(words) == 4 and words[2] == 'in'
-                    for_ops = []
-                    ops.append(('for', (words[1], words[3], for_ops)))
-                    ops_stack.append(ops)
-                    ops = for_ops
+                    ops_stack.append('for')
+                    self.loop_vars.add(words[1])
+                    code.add_line(
+                        "for c_%s in %s:" % (
+                            words[1],
+                            self.expr_code(words[3])
+                        )
+                    )
+                    code.indent()
                 elif words[0].startswith('end'):
                     # Endsomething.  Pop the ops stack
-                    ops = ops_stack.pop()
-                    assert ops[-1][0] == words[0][3:]
+                    end_what = words[0][3:]
+                    if ops_stack[-1] != end_what:
+                        raise SyntaxError("Mismatched end tag: %r" % end_what)
+                    ops_stack.pop()
+                    code.dedent()
                 else:
-                    raise SyntaxError("Don't understand tag %r" % words)
+                    raise SyntaxError("Don't understand tag: %r" % words[0])
             else:
-                ops.append(('lit', tok))
-
-        assert not ops_stack, "Unmatched action tag: %r" % ops_stack[-1][0]
-        self.ops = ops
+                # Literal content.  If it isn't empty, output it.
+                if tok:
+                    buffered.append("%r" % tok)
+        flush_output()
+
+        for var_name in self.all_vars - self.loop_vars:
+            vars_code.add_line("c_%s = ctx[%r]" % (var_name, var_name))
+
+        if ops_stack:
+            raise SyntaxError("Unmatched action tag: %r" % ops_stack[-1])
+
+        code.add_line("return ''.join(result)")
+        code.dedent()
+        self.render_function = code.get_function('render')
+
+    def expr_code(self, expr):
+        """Generate a Python expression for `expr`."""
+        if "|" in expr:
+            pipes = expr.split("|")
+            code = self.expr_code(pipes[0])
+            for func in pipes[1:]:
+                self.all_vars.add(func)
+                code = "c_%s(%s)" % (func, code)
+        elif "." in expr:
+            dots = expr.split(".")
+            code = self.expr_code(dots[0])
+            args = [repr(d) for d in dots[1:]]
+            code = "dot(%s, %s)" % (code, ", ".join(args))
+        else:
+            self.all_vars.add(expr)
+            code = "c_%s" % expr
+        return code
 
     def render(self, context=None):
         """Render this template by applying it to `context`.
@@ -97,70 +194,15 @@
         ctx = dict(self.context)
         if context:
             ctx.update(context)
-
-        # Run it through an engine, and return the result.
-        engine = _TempliteEngine(ctx)
-        engine.execute(self.ops)
-        return "".join(engine.result)
-
-
-class _TempliteEngine(object):
-    """Executes Templite objects to produce strings."""
-    def __init__(self, context):
-        self.context = context
-        self.result = []
-
-    def execute(self, ops):
-        """Execute `ops` in the engine.
-
-        Called recursively for the bodies of if's and loops.
-
-        """
-        for op, args in ops:
-            if op == 'lit':
-                self.result.append(args)
-            elif op == 'exp':
-                try:
-                    self.result.append(str(self.evaluate(args)))
-                except:
-                    exc_class, exc, _ = sys.exc_info()
-                    new_exc = exc_class("Couldn't evaluate {{ %s }}: %s"
-                                        % (args, exc))
-                    raise new_exc
-            elif op == 'if':
-                expr, body = args
-                if self.evaluate(expr):
-                    self.execute(body)
-            elif op == 'for':
-                var, lis, body = args
-                vals = self.evaluate(lis)
-                for val in vals:
-                    self.context[var] = val
-                    self.execute(body)
-            else:
-                raise AssertionError("TempliteEngine doesn't grok op %r" % op)
-
-    def evaluate(self, expr):
-        """Evaluate an expression.
-
-        `expr` can have pipes and dots to indicate data access and filtering.
-
-        """
-        if "|" in expr:
-            pipes = expr.split("|")
-            value = self.evaluate(pipes[0])
-            for func in pipes[1:]:
-                value = self.evaluate(func)(value)
-        elif "." in expr:
-            dots = expr.split('.')
-            value = self.evaluate(dots[0])
-            for dot in dots[1:]:
-                try:
-                    value = getattr(value, dot)
-                except AttributeError:
-                    value = value[dot]
-                if hasattr(value, '__call__'):
-                    value = value()
-        else:
-            value = self.context[expr]
+        return self.render_function(ctx, self.do_dots)
+
+    def do_dots(self, value, *dots):
+        """Evaluate dotted expressions at runtime."""
+        for dot in dots:
+            try:
+                value = getattr(value, dot)
+            except AttributeError:
+                value = value[dot]
+            if hasattr(value, '__call__'):
+                value = value()
         return value

=== modified file 'coverage/version.py'
--- coverage/version.py	2014-01-06 21:48:50 +0000
+++ coverage/version.py	2014-03-07 05:33:58 +0000
@@ -1,7 +1,7 @@
 """The version and URL for coverage.py"""
 # This file is exec'ed in setup.py, don't import anything!
 
-__version__ = "3.7"                     # see detailed history in CHANGES.txt
+__version__ = "3.7.1"                   # see detailed history in CHANGES.txt
 
 __url__ = "http://nedbatchelder.com/code/coverage"
 if max(__version__).isalpha():

=== modified file 'coverage/xmlreport.py'
--- coverage/xmlreport.py	2014-01-06 21:48:50 +0000
+++ coverage/xmlreport.py	2014-03-07 05:33:58 +0000
@@ -117,7 +117,7 @@
         branch_stats = analysis.branch_stats()
 
         # For each statement, create an XML 'line' element.
-        for line in analysis.statements:
+        for line in sorted(analysis.statements):
             xline = self.xml_out.createElement("line")
             xline.setAttribute("number", str(line))
 

=== modified file 'debian/changelog'
--- debian/changelog	2014-02-19 20:37:07 +0000
+++ debian/changelog	2014-03-07 05:33:58 +0000
@@ -1,3 +1,34 @@
+python-coverage (3.7.1+dfsg.1-1ubuntu1) trusty; urgency=medium
+
+  * Merge with Debian unstable, remaining change:
+    - Add python3-coverage.preinst to correctly handle upgrades from
+      previous releases.
+
+ -- Dmitry Shachnev <[e-mail]>  Fri, 07 Mar 2014 09:26:38 +0400
+
+python-coverage (3.7.1+dfsg.1-1) unstable; urgency=medium
+
+  * The “Ziauddin Yousafzai” release.
+  * Urgency “medium” because we fix a bug of severity “serious”.
+  * New upstream version.
+    (Closes: bug#735359)
+  * debian/patches/:
+    + Patches incorporated upstream:
+      * 02.use-system-ecmascript-libraries.patch
+      Remaining patch files re-sequenced contiguously.
+    + Add editor hints to patch files.
+  * debian/repack:
+    + Correct quoting of parameters (quote parameters used as filesystem
+      entry names, don't quote parameters used as numbers).
+  * debian/rules:
+    + Explicitly replace shebang for programs needing default Python
+      interpreter (Closes: bug#736121).
+    + Correct generation of Python version strings for object code
+      filenames (Closes: bug#740053).
+      Thanks to Dmitry Shachnev for the bug report and patch.
+
+ -- Ben Finney <[e-mail]>  Wed, 05 Mar 2014 13:14:27 +1100
+
 python-coverage (3.7+dfsg.1-4ubuntu2) trusty; urgency=medium
 
   * Build for python 3.4.

=== modified file 'debian/patches/01.omit-resource-files-from-distutils-setup.patch'
--- debian/patches/01.omit-resource-files-from-distutils-setup.patch	2013-10-15 13:16:36 +0000
+++ debian/patches/01.omit-resource-files-from-distutils-setup.patch	2014-03-07 05:33:58 +0000
@@ -32,3 +32,14 @@
  
      entry_points = {'console_scripts': scripts},
  
+
+

+Local variables:
+coding: utf-8
+mode: diff
+time-stamp-format: "%:y-%02m-%02d"
+time-stamp-start: "^Last-Update:[         ]+"
+time-stamp-end: "$"
+time-stamp-line-limit: 20
+End:
+vim: fileencoding=utf-8 filetype=diff :

=== added file 'debian/patches/02.rename-public-programs.patch'
--- debian/patches/02.rename-public-programs.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/02.rename-public-programs.patch	2014-03-07 05:33:58 +0000
@@ -0,0 +1,50 @@
+Description: Rename public programs to be clear what they're for.
+ .
+ The upstream choice of ‘coverage’ is too broad a command name for a
+ Python-specific programmer tool.
+ .
+ Created to work with “entry points” feature of Python's Distribute.
+Bug: https://bitbucket.org/ned/coveragepy/issue/272/
+Author: Ben Finney <[e-mail]>
+Last-Update: 2013-10-16
+
+--- old/setup.py	2013-10-07 07:40:00.000000000 +1100
++++ new/setup.py	2013-10-08 10:21:00.000000000 +1100
+@@ -1,3 +1,4 @@
++# coding: utf-8
+ # setup.py for coverage.py
+ 
+ """Code coverage measurement for Python
+@@ -71,13 +72,15 @@
+     devstat = "5 - Production/Stable"
+ classifier_list.append("Development Status :: " + devstat)
+ 
+-# Install a script as "coverage", and as "coverage[23]", and as
+-# "coverage-2.7" (or whatever).
++# Install a default ‘python-coverage’ program, and versioned as
++# ‘python2.7-coverage’, ‘python3-coverage’, etc.
+ scripts = [
+-    'coverage = coverage:main',
+-    'coverage%d = coverage:main' % sys.version_info[:1],
+-    'coverage-%d.%d = coverage:main' % sys.version_info[:2],
+-    ]
++        "python-coverage = coverage:main",
++        "python{version[0]}-coverage = coverage:main".format(
++            version=sys.version_info),
++        "python{version[0]}.{version[1]}-coverage = coverage:main".format(
++            version=sys.version_info),
++        ]
+ 
+ # Create the keyword arguments for setup()
+ 
+
+

+Local variables:
+coding: utf-8
+mode: diff
+time-stamp-format: "%:y-%02m-%02d"
+time-stamp-start: "^Last-Update:[         ]+"
+time-stamp-end: "$"
+time-stamp-line-limit: 20
+End:
+vim: fileencoding=utf-8 filetype=diff :

=== removed file 'debian/patches/02.use-system-ecmascript-libraries.patch'
--- debian/patches/02.use-system-ecmascript-libraries.patch	2013-10-15 13:16:36 +0000
+++ debian/patches/02.use-system-ecmascript-libraries.patch	1970-01-01 00:00:00 +0000
@@ -1,48 +0,0 @@
-Description: Use Debian packaged ECMAScript libraries.
- .
- Per Debian policy §4.13 “Convenience copies of code”, packages should not
- bundle third-party code. Instead, the program should use the system
- packages of those libraries.
-Bug: https://bitbucket.org/ned/coveragepy/issue/259/
-Bug-Debian: http://bugs.debian.org/596212
-Author: Ben Finney <[e-mail]>
-Last-Update: 2013-10-08
-
-diff -ruN old/coverage/html.py new/coverage/html.py
---- old/coverage/html.py	2013-10-07 07:40:00.000000000 +1100
-+++ new/coverage/html.py	2013-10-08 10:21:00.000000000 +1100
-@@ -48,10 +48,6 @@
-     # These files will be copied from the htmlfiles dir to the output dir.
-     STATIC_FILES = [
-             "style.css",
--            "jquery.min.js",
--            "jquery.hotkeys.js",
--            "jquery.isonscreen.js",
--            "jquery.tablesorter.min.js",
-             "coverage_html.js",
-             "keybd_closed.png",
-             "keybd_open.png",
-@@ -123,6 +119,23 @@
-                 os.path.join(self.directory, static)
-                 )
- 
-+        system_javascript_path = os.path.join(
-+                os.sep, "usr", "share", "javascript")
-+        system_javascript_libraries = {
-+                "jquery.min.js":
-+                    os.path.join(system_javascript_path, "jquery"),
-+                "jquery.hotkeys.js":
-+                    os.path.join(system_javascript_path, "jquery-hotkeys"),
-+                "jquery.isonscreen.js":
-+                    os.path.join(system_javascript_path, "jquery-isonscreen"),
-+                "jquery.tablesorter.min.js":
-+                    os.path.join(system_javascript_path, "jquery-tablesorter"),
-+                }
-+        for static, source_dir in system_javascript_libraries.items():
-+            shutil.copyfile(
-+                    os.path.join(source_dir, static),
-+                    os.path.join(self.directory, static))
-+
-         # The user may have extra CSS they want copied.
-         if self.extra_css:
-             shutil.copyfile(

=== removed file 'debian/patches/03.rename-public-programs.patch'
--- debian/patches/03.rename-public-programs.patch	2013-10-29 09:13:11 +0000
+++ debian/patches/03.rename-public-programs.patch	1970-01-01 00:00:00 +0000
@@ -1,39 +0,0 @@
-Description: Rename public programs to be clear what they're for.
- .
- The upstream choice of ‘coverage’ is too broad a command name for a
- Python-specific programmer tool.
- .
- Created to work with “entry points” feature of Python's Distribute.
-Bug: https://bitbucket.org/ned/coveragepy/issue/272/
-Author: Ben Finney <[e-mail]>
-Last-Update: 2013-10-16
-
---- old/setup.py	2013-10-07 07:40:00.000000000 +1100
-+++ new/setup.py	2013-10-08 10:21:00.000000000 +1100
-@@ -1,3 +1,4 @@
-+# coding: utf-8
- # setup.py for coverage.py
- 
- """Code coverage measurement for Python
-@@ -71,13 +72,15 @@
-     devstat = "5 - Production/Stable"
- classifier_list.append("Development Status :: " + devstat)
- 
--# Install a script as "coverage", and as "coverage[23]", and as
--# "coverage-2.7" (or whatever).
-+# Install a default ‘python-coverage’ program, and versioned as
-+# ‘python2.7-coverage’, ‘python3-coverage’, etc.
- scripts = [
--    'coverage = coverage:main',
--    'coverage%d = coverage:main' % sys.version_info[:1],
--    'coverage-%d.%d = coverage:main' % sys.version_info[:2],
--    ]
-+        "python-coverage = coverage:main",
-+        "python{version[0]}-coverage = coverage:main".format(
-+            version=sys.version_info),
-+        "python{version[0]}.{version[1]}-coverage = coverage:main".format(
-+            version=sys.version_info),
-+        ]
- 
- # Create the keyword arguments for setup()
- 

=== modified file 'debian/patches/series'
--- debian/patches/series	2014-01-06 21:48:50 +0000
+++ debian/patches/series	2014-03-07 05:33:58 +0000
@@ -1,3 +1,2 @@
 01.omit-resource-files-from-distutils-setup.patch
-02.use-system-ecmascript-libraries.patch
-03.rename-public-programs.patch
+02.rename-public-programs.patch

=== removed file 'debian/python-coverage.1'
--- debian/python-coverage.1	2014-02-19 20:37:07 +0000
+++ debian/python-coverage.1	1970-01-01 00:00:00 +0000
@@ -1,279 +0,0 @@
-'\" -*- coding: utf-8 -*-
-.\" Man page generated from reStructuredText.
-.
-.TH PYTHON-COVERAGE 1 "2013-10-07" "" "Coverage"
-.SH NAME
-python-coverage \- measure code coverage of Python program execution
-.
-.nr rst2man-indent-level 0
-.
-.de1 rstReportMargin
-\\$1 \\n[an-margin]
-level \\n[rst2man-indent-level]
-level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
--
-\\n[rst2man-indent0]
-\\n[rst2man-indent1]
-\\n[rst2man-indent2]
-..
-.de1 INDENT
-.\" .rstReportMargin pre:
-. RS \\$1
-. nr rst2man-indent\\n[rst2man-indent-level] \\n[an-margin]
-. nr rst2man-indent-level +1
-.\" .rstReportMargin post:
-..
-.de UNINDENT
-. RE
-.\" indent \\n[an-margin]
-.\" old: \\n[rst2man-indent\\n[rst2man-indent-level]]
-.nr rst2man-indent-level -1
-.\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
-.in \\n[rst2man-indent\\n[rst2man-indent-level]]u
-..
-.SH SYNOPSIS
-.nf
-\fBpython\-coverage\fP \fIcommand\fP [ \fIoption\fP ... ]
-\fBpython\-coverage\fP \fBhelp\fP [ \fIcommand\fP ]
-\fBpython\-coverage\fP \fBhelp\fP \fBclassic\fP
-.fi
-.sp
-.SH DESCRIPTION
-.sp
-\fBpython\-coverage\fP executes a Python program, measures which of its statements are
-executed and which are not, and reports these coverage measurements.
-.SH COMMAND OVERVIEW
-.INDENT 0.0
-.TP
-.B \fBpython\-coverage\fP \fBannotate\fP
-Annotate source files with execution information.
-.TP
-.B \fBpython\-coverage\fP \fBcombine\fP
-Combine a number of data files.
-.TP
-.B \fBpython\-coverage\fP \fBerase\fP
-Erase previously collected coverage data.
-.TP
-.B \fBpython\-coverage\fP \fBhelp\fP
-Get help on using coverage.py.
-.TP
-.B \fBpython\-coverage\fP \fBhtml\fP
-Create an HTML report.
-.TP
-.B \fBpython\-coverage\fP \fBreport\fP
-Report coverage stats on modules.
-.TP
-.B \fBpython\-coverage\fP \fBrun\fP
-Run a Python program and measure code execution.
-.TP
-.B \fBpython\-coverage\fP \fBxml\fP
-Create an XML report of coverage results.
-.UNINDENT
-.SH GLOBAL OPTIONS
-.INDENT 0.0
-.TP
-.B \fB\-\-help\fP, \fB\-h\fP
-Describe how to use Coverage, in general or a command.
-.TP
-.B \fB\-\-rcfile\fP \fIRCFILE\fP
-Specify configuration file \fIRCFILE\fP\&. Defaults to \fB\&.coveragerc\fP\&.
-.TP
-.B \fB\-\-omit\fP \fIPATTERN\fP ...
-Omit files when their filename matches one of these PATTERNs.
-Usually needs quoting on the command line.
-.TP
-.B \fB\-\-include\fP \fIPATTERN\fP ...
-Include files only when their filename path matches one of these
-PATTERNs. Usually needs quoting on the command line.
-.UNINDENT
-.SH COMMAND REFERENCE
-.sp
-\fBannotate\fP
-.INDENT 0.0
-.INDENT 3.5
-Options:
-.INDENT 0.0
-.TP
-.B \-d \fIDIR\fP, \-\-directory \fIDIR\fP
-Write the output files to DIR.
-.TP
-.B \-i, \-\-ignore\-errors
-Ignore errors while reading source files.
-.UNINDENT
-.UNINDENT
-.UNINDENT
-.sp
-\fBcombine\fP
-.INDENT 0.0
-.INDENT 3.5
-Combine data from multiple coverage files collected with \fBrun \-p\fP\&.
-The combined results are written to a single file representing the
-union of the data.
-.UNINDENT
-.UNINDENT
-.sp
-\fBerase\fP
-.INDENT 0.0
-.INDENT 3.5
-Erase previously collected coverage data.
-.UNINDENT
-.UNINDENT
-.sp
-\fBhelp\fP [ \fIcommand\fP ]
-.INDENT 0.0
-.INDENT 3.5
-Describe how to use Coverage.
-.UNINDENT
-.UNINDENT
-.sp
-\fBhelp\fP \fBclassic\fP
-.INDENT 0.0
-.INDENT 3.5
-Describe help on older command syntax.
-.UNINDENT
-.UNINDENT
-.sp
-\fBhtml\fP [ \fIoption\fP ... ] [ \fIMODULE\fP ... ]
-.INDENT 0.0
-.INDENT 3.5
-Create an HTML report of the coverage of each \fIMODULE\fP file. Each file
-gets its own page, with the source decorated to show executed,
-excluded, and missed lines.
-.sp
-Options:
-.INDENT 0.0
-.TP
-.B \-d \fIDIR\fP, \-\-directory \fIDIR\fP
-Write the output files to \fIDIR\fP\&.
-.TP
-.B \-\-title \fITITLE\fP
-Use the text string \fITITLE\fP as the title on the HTML.
-.TP
-.B \-\-fail\-under \fIMIN\fP
-Exit with a status of 2 if the total coverage is less than \fIMIN\fP\&.
-.TP
-.B \-i, \-\-ignore\-errors
-Ignore errors while reading source files.
-.UNINDENT
-.UNINDENT
-.UNINDENT
-.sp
-\fBreport\fP [ \fIoption\fP ... ] [ \fIMODULE\fP ... ]
-.INDENT 0.0
-.INDENT 3.5
-Report coverage statistics on each \fIMODULE\fP\&.
-.sp
-Options:
-.INDENT 0.0
-.TP
-.B \-\-fail\-under \fIMIN\fP
-Exit with a status of 2 if the total coverage is less than \fIMIN\fP\&.
-.TP
-.B \-i, \-\-ignore\-errors
-Ignore errors while reading source files.
-.TP
-.B \-m, \-\-show\-missing
-Show line numbers of statements in each module that weren\(aqt
-executed.
-.UNINDENT
-.UNINDENT
-.UNINDENT
-.sp
-\fBrun\fP [ \fIoptions\fP ... ] \fIPROGRAMFILE\fP [ \fIprogram_options\fP ]
-.INDENT 0.0
-.INDENT 3.5
-Run a Python program \fIPROGRAMFILE\fP, measuring code execution.
-.sp
-Options:
-.INDENT 0.0
-.TP
-.B \-a, \-\-append
-Append coverage data to .coverage, otherwise it is started clean
-with each run.
-.TP
-.B \-\-branch
-Measure branch coverage in addition to statement coverage.
-.TP
-.B \-\-debug \fIDEBUGOPT\fP,...
-Debug options \fIDEBUGOPT\fP, separated by commas
-.TP
-.B \-L, \-\-pylib
-Measure coverage even inside the Python installed library, which
-isn\(aqt done by default.
-.TP
-.B \-p, \-\-parallel\-mode
-Append the machine name, process id and random number to the
-\fB\&.coverage\fP data file name to simplify collecting data from many
-processes.
-.TP
-.B \-\-timid
-Use a simpler but slower trace method. Try this if you get
-seemingly impossible results!
-.TP
-.B \-\-source \fISOURCE\fP ...
-A list of packages or directories of code to be measured.
-.UNINDENT
-.UNINDENT
-.UNINDENT
-.sp
-\fBxml\fP [ \fIoptions\fP ... ] [ \fIMODULES\fP ... ]
-.INDENT 0.0
-.INDENT 3.5
-Generate an XML report of coverage results on each \fIMODULE\fP\&.
-.sp
-Options:
-.INDENT 0.0
-.TP
-.B \-\-fail\-under \fIMIN\fP
-Exit with a status of 2 if the total coverage is less than \fIMIN\fP\&.
-.TP
-.B \-i, \-\-ignore\-errors
-Ignore errors while reading source files.
-.TP
-.B \-o \fIOUTFILE\fP
-Write the XML report to \fIOUTFILE\fP\&. Defaults to \fBcoverage.xml\fP\&.
-.UNINDENT
-.UNINDENT
-.UNINDENT
-.SH ENVIRONMENT VARIABLES
-.sp
-COVERAGE_FILE
-.INDENT 0.0
-.INDENT 3.5
-Path to the file where coverage measurements are collected to and
-reported from. Default: \fB\&.coverage\fP in the current working directory.
-.UNINDENT
-.UNINDENT
-.sp
-COVERAGE_OPTIONS
-.INDENT 0.0
-.INDENT 3.5
-Space\-separated series of command\-line options to \fBpython\-coverage\fP\&. Default:
-empty.
-.UNINDENT
-.UNINDENT
-.SH HISTORY
-.sp
-The \fBpython\-coverage\fP command is a Python program which calls the \fBcoverage\fP
-Python library to do all the work.
-.sp
-The library was originally developed by Gareth Rees, and is now developed
-by Ned Batchelder.
-.sp
-This manual page was written by Ben Finney <\fI\[e-mail]\fP>\&.
-.\" Local variables:
-.\" mode: rst
-.\" coding: utf-8
-.\" time-stamp-format: "%:y-%02m-%02d"
-.\" time-stamp-start: "^:Date:[         ]+"
-.\" time-stamp-end: "$"
-.\" time-stamp-line-limit: 20
-.\" End:
-.\" vim: filetype=rst fileencoding=utf-8 :
-.
-.SH AUTHOR
-Ben Finney <[e-mail]>
-.SH COPYRIGHT
-BSD license, attribution and disclaimer required.
-.\" Generated by docutils manpage writer.
-.

=== removed file 'debian/python-coverage.1.tmp'
--- debian/python-coverage.1.tmp	2014-02-19 20:37:07 +0000
+++ debian/python-coverage.1.tmp	1970-01-01 00:00:00 +0000
@@ -1,278 +0,0 @@
-.\" Man page generated from reStructuredText.
-.
-.TH PYTHON-COVERAGE 1 "2013-10-07" "" "Coverage"
-.SH NAME
-python-coverage \- measure code coverage of Python program execution
-.
-.nr rst2man-indent-level 0
-.
-.de1 rstReportMargin
-\\$1 \\n[an-margin]
-level \\n[rst2man-indent-level]
-level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
--
-\\n[rst2man-indent0]
-\\n[rst2man-indent1]
-\\n[rst2man-indent2]
-..
-.de1 INDENT
-.\" .rstReportMargin pre:
-. RS \\$1
-. nr rst2man-indent\\n[rst2man-indent-level] \\n[an-margin]
-. nr rst2man-indent-level +1
-.\" .rstReportMargin post:
-..
-.de UNINDENT
-. RE
-.\" indent \\n[an-margin]
-.\" old: \\n[rst2man-indent\\n[rst2man-indent-level]]
-.nr rst2man-indent-level -1
-.\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
-.in \\n[rst2man-indent\\n[rst2man-indent-level]]u
-..
-.SH SYNOPSIS
-.nf
-\fBpython\-coverage\fP \fIcommand\fP [ \fIoption\fP ... ]
-\fBpython\-coverage\fP \fBhelp\fP [ \fIcommand\fP ]
-\fBpython\-coverage\fP \fBhelp\fP \fBclassic\fP
-.fi
-.sp
-.SH DESCRIPTION
-.sp
-\fBpython\-coverage\fP executes a Python program, measures which of its statements are
-executed and which are not, and reports these coverage measurements.
-.SH COMMAND OVERVIEW
-.INDENT 0.0
-.TP
-.B \fBpython\-coverage\fP \fBannotate\fP
-Annotate source files with execution information.
-.TP
-.B \fBpython\-coverage\fP \fBcombine\fP
-Combine a number of data files.
-.TP
-.B \fBpython\-coverage\fP \fBerase\fP
-Erase previously collected coverage data.
-.TP
-.B \fBpython\-coverage\fP \fBhelp\fP
-Get help on using coverage.py.
-.TP
-.B \fBpython\-coverage\fP \fBhtml\fP
-Create an HTML report.
-.TP
-.B \fBpython\-coverage\fP \fBreport\fP
-Report coverage stats on modules.
-.TP
-.B \fBpython\-coverage\fP \fBrun\fP
-Run a Python program and measure code execution.
-.TP
-.B \fBpython\-coverage\fP \fBxml\fP
-Create an XML report of coverage results.
-.UNINDENT
-.SH GLOBAL OPTIONS
-.INDENT 0.0
-.TP
-.B \fB\-\-help\fP, \fB\-h\fP
-Describe how to use Coverage, in general or a command.
-.TP
-.B \fB\-\-rcfile\fP \fIRCFILE\fP
-Specify configuration file \fIRCFILE\fP\&. Defaults to \fB\&.coveragerc\fP\&.
-.TP
-.B \fB\-\-omit\fP \fIPATTERN\fP ...
-Omit files when their filename matches one of these PATTERNs.
-Usually needs quoting on the command line.
-.TP
-.B \fB\-\-include\fP \fIPATTERN\fP ...
-Include files only when their filename path matches one of these
-PATTERNs. Usually needs quoting on the command line.
-.UNINDENT
-.SH COMMAND REFERENCE
-.sp
-\fBannotate\fP
-.INDENT 0.0
-.INDENT 3.5
-Options:
-.INDENT 0.0
-.TP
-.B \-d \fIDIR\fP, \-\-directory \fIDIR\fP
-Write the output files to DIR.
-.TP
-.B \-i, \-\-ignore\-errors
-Ignore errors while reading source files.
-.UNINDENT
-.UNINDENT
-.UNINDENT
-.sp
-\fBcombine\fP
-.INDENT 0.0
-.INDENT 3.5
-Combine data from multiple coverage files collected with \fBrun \-p\fP\&.
-The combined results are written to a single file representing the
-union of the data.
-.UNINDENT
-.UNINDENT
-.sp
-\fBerase\fP
-.INDENT 0.0
-.INDENT 3.5
-Erase previously collected coverage data.
-.UNINDENT
-.UNINDENT
-.sp
-\fBhelp\fP [ \fIcommand\fP ]
-.INDENT 0.0
-.INDENT 3.5
-Describe how to use Coverage.
-.UNINDENT
-.UNINDENT
-.sp
-\fBhelp\fP \fBclassic\fP
-.INDENT 0.0
-.INDENT 3.5
-Describe help on older command syntax.
-.UNINDENT
-.UNINDENT
-.sp
-\fBhtml\fP [ \fIoption\fP ... ] [ \fIMODULE\fP ... ]
-.INDENT 0.0
-.INDENT 3.5
-Create an HTML report of the coverage of each \fIMODULE\fP file. Each file
-gets its own page, with the source decorated to show executed,
-excluded, and missed lines.
-.sp
-Options:
-.INDENT 0.0
-.TP
-.B \-d \fIDIR\fP, \-\-directory \fIDIR\fP
-Write the output files to \fIDIR\fP\&.
-.TP
-.B \-\-title \fITITLE\fP
-Use the text string \fITITLE\fP as the title on the HTML.
-.TP
-.B \-\-fail\-under \fIMIN\fP
-Exit with a status of 2 if the total coverage is less than \fIMIN\fP\&.
-.TP
-.B \-i, \-\-ignore\-errors
-Ignore errors while reading source files.
-.UNINDENT
-.UNINDENT
-.UNINDENT
-.sp
-\fBreport\fP [ \fIoption\fP ... ] [ \fIMODULE\fP ... ]
-.INDENT 0.0
-.INDENT 3.5
-Report coverage statistics on each \fIMODULE\fP\&.
-.sp
-Options:
-.INDENT 0.0
-.TP
-.B \-\-fail\-under \fIMIN\fP
-Exit with a status of 2 if the total coverage is less than \fIMIN\fP\&.
-.TP
-.B \-i, \-\-ignore\-errors
-Ignore errors while reading source files.
-.TP
-.B \-m, \-\-show\-missing
-Show line numbers of statements in each module that weren\(aqt
-executed.
-.UNINDENT
-.UNINDENT
-.UNINDENT
-.sp
-\fBrun\fP [ \fIoptions\fP ... ] \fIPROGRAMFILE\fP [ \fIprogram_options\fP ]
-.INDENT 0.0
-.INDENT 3.5
-Run a Python program \fIPROGRAMFILE\fP, measuring code execution.
-.sp
-Options:
-.INDENT 0.0
-.TP
-.B \-a, \-\-append
-Append coverage data to .coverage, otherwise it is started clean
-with each run.
-.TP
-.B \-\-branch
-Measure branch coverage in addition to statement coverage.
-.TP
-.B \-\-debug \fIDEBUGOPT\fP,...
-Debug options \fIDEBUGOPT\fP, separated by commas
-.TP
-.B \-L, \-\-pylib
-Measure coverage even inside the Python installed library, which
-isn\(aqt done by default.
-.TP
-.B \-p, \-\-parallel\-mode
-Append the machine name, process id and random number to the
-\fB\&.coverage\fP data file name to simplify collecting data from many
-processes.
-.TP
-.B \-\-timid
-Use a simpler but slower trace method. Try this if you get
-seemingly impossible results!
-.TP
-.B \-\-source \fISOURCE\fP ...
-A list of packages or directories of code to be measured.
-.UNINDENT
-.UNINDENT
-.UNINDENT
-.sp
-\fBxml\fP [ \fIoptions\fP ... ] [ \fIMODULES\fP ... ]
-.INDENT 0.0
-.INDENT 3.5
-Generate an XML report of coverage results on each \fIMODULE\fP\&.
-.sp
-Options:
-.INDENT 0.0
-.TP
-.B \-\-fail\-under \fIMIN\fP
-Exit with a status of 2 if the total coverage is less than \fIMIN\fP\&.
-.TP
-.B \-i, \-\-ignore\-errors
-Ignore errors while reading source files.
-.TP
-.B \-o \fIOUTFILE\fP
-Write the XML report to \fIOUTFILE\fP\&. Defaults to \fBcoverage.xml\fP\&.
-.UNINDENT
-.UNINDENT
-.UNINDENT
-.SH ENVIRONMENT VARIABLES
-.sp
-COVERAGE_FILE
-.INDENT 0.0
-.INDENT 3.5
-Path to the file where coverage measurements are collected to and
-reported from. Default: \fB\&.coverage\fP in the current working directory.
-.UNINDENT
-.UNINDENT
-.sp
-COVERAGE_OPTIONS
-.INDENT 0.0
-.INDENT 3.5
-Space\-separated series of command\-line options to \fBpython\-coverage\fP\&. Default:
-empty.
-.UNINDENT
-.UNINDENT
-.SH HISTORY
-.sp
-The \fBpython\-coverage\fP command is a Python program which calls the \fBcoverage\fP
-Python library to do all the work.
-.sp
-The library was originally developed by Gareth Rees, and is now developed
-by Ned Batchelder.
-.sp
-This manual page was written by Ben Finney <\fI\[e-mail]\fP>\&.
-.\" Local variables:
-.\" mode: rst
-.\" coding: utf-8
-.\" time-stamp-format: "%:y-%02m-%02d"
-.\" time-stamp-start: "^:Date:[         ]+"
-.\" time-stamp-end: "$"
-.\" time-stamp-line-limit: 20
-.\" End:
-.\" vim: filetype=rst fileencoding=utf-8 :
-.
-.SH AUTHOR
-Ben Finney <[e-mail]>
-.SH COPYRIGHT
-BSD license, attribution and disclaimer required.
-.\" Generated by docutils manpage writer.
-.

=== modified file 'debian/repack'
--- debian/repack	2014-01-13 14:51:52 +0000
+++ debian/repack	2014-03-07 05:33:58 +0000
@@ -7,11 +7,11 @@
 set -o nounset
 
 function usage() {
-    progname=$(basename $0)
+    progname="$(basename "$0")"
     printf "$progname --upstream-version VERSION FILENAME\n"
 }
 
-if [ "$#" -ne "3" ] ; then
+if [ $# -ne 3 ] ; then
     usage
     exit 1
 fi

=== modified file 'debian/rules'
--- debian/rules	2014-01-13 14:51:52 +0000
+++ debian/rules	2014-03-07 05:33:58 +0000
@@ -22,13 +22,22 @@
 PYTHON3_VERSIONS = $(shell py3versions -vr)
 PYTHON_VERSIONS = ${PYTHON2_VERSIONS} ${PYTHON3_VERSIONS}
 
+# For some ‘/usr/bin/*-coverage’ programs (and not others), we need the
+# default, not current, Python interpreter in the shebang. The ‘dh-python’
+# helpers can re-write shebangs, but they are too eager, converting every
+# program's shebang without allowing us to specify different interpreters
+# per program. We resort to ‘sed’.
+python3_program = ${package_install_bin_dir}/python3-coverage
+shebang_line_regex = ^\#!.*$$
+python3_shebang_interpreter = /usr/bin/python3
+
 debug_object_exclude += _d.so
 
 # Unfortunately, ‘dh_install --exclude’ requires a substring, and a glob
 # wildcard will *not* work. So we need to specify the exact substring for
 # the Python 3 debug module filenames.
 python3_objcode_versions = $(shell \
-	printf "%s" ${PYTHON3_VERSIONS} | sed -e 's/\.//g')
+	printf "%s\n" ${PYTHON3_VERSIONS} | sed -e 's/\.//g')
 DEB_HOST_MULTIARCH = $(shell dpkg-architecture -qDEB_HOST_MULTIARCH)
 debug_object_exclude += $(foreach ver,${python3_objcode_versions}, \
 	.cpython-${ver}dm-${DEB_HOST_MULTIARCH}.so)
@@ -112,14 +121,14 @@
 manpage-symlinks: ${versioned_manpage_paths}
 
 ${DOCUMENTATION_DIR}/${default_manpage_name}: ${package_working_root}/${default_manpage_name}
-	$(INSTALL) --mode=u=rw,go=r $< $@
+	$(INSTALL) --mode=u=rw,go=r "$<" "$@"
 
 ${DOCUMENTATION_DIR}/%${MANPAGE_SUFFIX}: ${DOCUMENTATION_DIR}/${default_manpage_name}
-	ln -s ${default_manpage_name} $@
+	ln -s ${default_manpage_name} "$@"
 
 %.1: %.1${RST_SUFFIX}
-	$(RST2MAN) $< > $@.tmp
-	cat debian/manpage_encoding_declaration.UTF-8 $@.tmp > $@
+	$(RST2MAN) $< > "$@".tmp
+	cat debian/manpage_encoding_declaration.UTF-8 "$@".tmp > "$@"
 
 

 .PHONY: clean
@@ -158,22 +167,27 @@
 	        --exclude ${exclude_part})
 
 ${package_install_resources_root}:
-	$(INSTALL) -d $@
+	$(INSTALL) -d "$@"
 
 ${package_install_resources_root}/${htmlfiles_dirname}: ${HTMLFILES_DIR} ${package_install_resources_root}
-	$(INSTALL) -d $@
-	$(INSTALL) --mode=u=rw,go=r $</* $@
+	$(INSTALL) -d "$@"
+	$(INSTALL) --mode=u=rw,go=r "$<"/* "$@"
 
 .PHONY: install-resource-files
 install-resource-files: ${package_install_resources_root}
 install-resource-files: ${package_install_resources_root}/${htmlfiles_dirname}
 
 .PHONY: install-python%
+install-python%: python_version_major = $(firstword $(subst ., ,$*))
 install-python%:
 	python$*-dbg setup.py install --install-layout=deb \
 	    --root=$(CURDIR)/${package_install_root}
 	python$* setup.py install --install-layout=deb \
 	    --root=$(CURDIR)/${package_install_root}
+	if [ "${python_version_major}" = "3" ] ; then \
+	    sed -i -e '1 s,${shebang_line_regex},#! ${python3_shebang_interpreter},' \
+	        "${python3_program}" ; \
+	fi
 
 

 .PHONY: binary-indep

=== modified file 'doc/changes.rst'
--- doc/changes.rst	2014-01-06 21:48:50 +0000
+++ doc/changes.rst	2014-03-07 05:33:58 +0000
@@ -26,6 +26,7 @@
 :history: 20121223T180600, updated for 3.6b2.
 :history: 20130105T173500, updated for 3.6
 :history: 20131005T205700, updated for 3.7
+:history: 20131212T213100, updated for 3.7.1
 
 
 These are the major changes for coverage.py.  For a more complete change
@@ -34,11 +35,25 @@
 .. _CHANGES.txt: http://bitbucket.org/ned/coveragepy/src/tip/CHANGES.txt
 
 
+.. _changes_371:
+
+Version 3.7.1 --- 13 December 2013
+----------------------------------
+
+- Improved the speed of HTML report generation by about 20%.
+
+- Fixed the mechanism for finding OS-installed static files for the HTML report
+  so that it will actually find OS-installed static files.
+
+
+.. _changes_37:
+
 Version 3.7 --- 6 October 2013
 ------------------------------
 
 - Added the ``--debug`` switch to ``coverage run``.  It accepts a list of
-  options indicating the type of internal activity to log to stderr.
+  options indicating the type of internal activity to log to stderr. For
+  details, see :ref:`the run --debug options <cmd_run_debug>`.
 
 - Improved the branch coverage facility, fixing `issue 92`_ and `issue 175`_.
 

=== modified file 'doc/cmd.rst'
--- doc/cmd.rst	2014-01-06 21:48:50 +0000
+++ doc/cmd.rst	2014-03-07 05:33:58 +0000
@@ -152,9 +152,9 @@
 
 * ``sys``: before starting, dump all the system and environment information,
   as with :ref:`coverage debug sys <cmd_debug>`.
-  
+
 * ``dataio``: log when reading or writing any data file.
-  
+
 * ``pid``: annotate all debug output with the process id.
 
 

=== modified file 'doc/index.rst'
--- doc/index.rst	2014-01-06 21:48:50 +0000
+++ doc/index.rst	2014-03-07 05:33:58 +0000
@@ -30,6 +30,7 @@
 :history: 20121229T112300, Updated for 3.6b3.
 :history: 20130105T174000, Updated for 3.6
 :history: 20131005T210000, Updated for 3.7
+:history: 20131212T213300, Updated for 3.7.1
 
 
 Coverage.py is a tool for measuring code coverage of Python programs. It
@@ -42,7 +43,7 @@
 
 .. ifconfig:: not prerelease
 
-    The latest version is coverage.py 3.7, released 6 October 2013.
+    The latest version is coverage.py 3.7.1, released 13 December 2013.
     It is supported on Python versions 2.3 through 3.4, and PyPy 2.1.
 
 .. ifconfig:: prerelease

=== modified file 'doc/install.rst'
--- doc/install.rst	2014-01-06 21:48:50 +0000
+++ doc/install.rst	2014-03-07 05:33:58 +0000
@@ -19,6 +19,7 @@
 :history: 20121229T112400, updated for 3.6b3.
 :history: 20130105T174400, updated for 3.6.
 :history: 20131005T210600, updated for 3.7.
+:history: 20131212T213500, updated for 3.7.1.
 
 
 .. highlight:: console
@@ -74,9 +75,9 @@
 installed properly::
 
     $ coverage --version
-    Coverage.py, version 3.7.  http://nedbatchelder.com/code/coverage
+    Coverage.py, version 3.7.1.  http://nedbatchelder.com/code/coverage
 
 You can also invoke coverage as a module::
 
     $ python -m coverage --version
-    Coverage.py, version 3.7.  http://nedbatchelder.com/code/coverage
+    Coverage.py, version 3.7.1.  http://nedbatchelder.com/code/coverage

=== modified file 'tests/coveragetest.py'
--- tests/coveragetest.py	2013-10-15 13:16:36 +0000
+++ tests/coveragetest.py	2014-03-07 05:33:58 +0000
@@ -355,20 +355,21 @@
 
         # Get the analysis results, and check that they are right.
         analysis = cov._analyze(mod)
+        statements = sorted(analysis.statements)
         if lines is not None:
             if type(lines[0]) == type(1):
                 # lines is just a list of numbers, it must match the statements
                 # found in the code.
-                self.assertEqual(analysis.statements, lines)
+                self.assertEqual(statements, lines)
             else:
                 # lines is a list of possible line number lists, one of them
                 # must match.
                 for line_list in lines:
-                    if analysis.statements == line_list:
+                    if statements == line_list:
                         break
                 else:
                     self.fail("None of the lines choices matched %r" %
-                                                        analysis.statements
+                                                                statements
                         )
 
             if type(missing) == type(""):

=== modified file 'tests/test_html.py'
--- tests/test_html.py	2013-10-15 13:16:36 +0000
+++ tests/test_html.py	2014-03-07 05:33:58 +0000
@@ -317,9 +317,32 @@
         cov = coverage.coverage()
         self.start_import_stop(cov, "main")
         cov.html_report()
+
         jquery = open("htmlcov/jquery.min.js").read()
         self.assertEqual(jquery, "Not Really JQuery!")
 
+    def test_copying_static_files_from_system_in_dir(self):
+        # Make a new place for static files.
+        INSTALLED = [
+            "jquery/jquery.min.js",
+            "jquery-hotkeys/jquery.hotkeys.js",
+            "jquery-isonscreen/jquery.isonscreen.js",
+            "jquery-tablesorter/jquery.tablesorter.min.js",
+        ]
+        for fpath in INSTALLED:
+            self.make_file(os.path.join("static_here", fpath), "Not real.")
+        coverage.html.STATIC_PATH.insert(0, "static_here")
+
+        self.make_file("main.py", "print(17)")
+        cov = coverage.coverage()
+        self.start_import_stop(cov, "main")
+        cov.html_report()
+
+        for fpath in INSTALLED:
+            the_file = os.path.basename(fpath)
+            contents = open(os.path.join("htmlcov", the_file)).read()
+            self.assertEqual(contents, "Not real.")
+
     def test_cant_find_static_files(self):
         # Make the path point to useless places.
         coverage.html.STATIC_PATH = ["/xyzzy"]

=== modified file 'tests/test_templite.py'
--- tests/test_templite.py	2013-10-15 13:16:36 +0000
+++ tests/test_templite.py	2014-03-07 05:33:58 +0000
@@ -1,7 +1,7 @@
 """Tests for coverage.templite."""
 
 from coverage.templite import Templite
-import unittest
+from tests.coveragetest import CoverageTest
 
 # pylint: disable=W0612,E1101
 # Disable W0612 (Unused variable) and
@@ -18,9 +18,11 @@
             setattr(self, n, v)
 
 
-class TempliteTest(unittest.TestCase):
+class TempliteTest(CoverageTest):
     """Tests for Templite."""
 
+    run_in_temp_dir = False
+
     def try_render(self, text, ctx, result):
         """Render `text` through `ctx`, and it had better be `result`."""
         self.assertEqual(Templite(text).render(ctx), result)
@@ -37,6 +39,14 @@
         # Variables use {{var}} syntax.
         self.try_render("Hello, {{name}}!", {'name':'Ned'}, "Hello, Ned!")
 
+    def test_undefined_variables(self):
+        # Using undefined names is an error.
+        self.assertRaises(
+            Exception,
+            self.try_render,
+            "Hi, {{name}}!", {}, "xyz"
+        )
+
     def test_pipes(self):
         # Variables can be filtered with pipes.
         data = {
@@ -165,6 +175,23 @@
             "Hi, NEDBEN!"
             )
 
+    def test_complex_if(self):
+        class Complex(AnyOldObject):
+            """A class to try out complex data access."""
+            def getit(self):
+                """Return it."""
+                return self.it
+        obj = Complex(it={'x':"Hello", 'y': 0})
+        self.try_render(
+            "@"
+            "{% if obj.getit.x %}X{% endif %}"
+            "{% if obj.getit.y %}Y{% endif %}"
+            "{% if obj.getit.y|str %}S{% endif %}"
+            "!",
+            { 'obj': obj, 'str': str },
+            "@XS!"
+            )
+
     def test_loop_if(self):
         self.try_render(
             "@{% for n in nums %}{% if n %}Z{% endif %}{{n}}{% endfor %}!",
@@ -184,9 +211,11 @@
 
     def test_nested_loops(self):
         self.try_render(
-            "@{% for n in nums %}"
+            "@"
+            "{% for n in nums %}"
                 "{% for a in abc %}{{a}}{{n}}{% endfor %}"
-            "{% endfor %}!",
+            "{% endfor %}"
+            "!",
             {'nums': [0,1,2], 'abc': ['a', 'b', 'c']},
             "@a0b0c0a1b1c1a2b2c2!"
             )
@@ -199,6 +228,20 @@
             )
 
     def test_bogus_tag_syntax(self):
-        self.assertRaises(SyntaxError, self.try_render,
+        self.assertRaisesRegexp(
+            SyntaxError, "Don't understand tag: 'bogus'",
+            self.try_render,
             "Huh: {% bogus %}!!{% endbogus %}??", {}, ""
             )
+
+    def test_bad_nesting(self):
+        self.assertRaisesRegexp(
+            SyntaxError, "Unmatched action tag: 'if'",
+            self.try_render,
+            "{% if x %}X", {}, ""
+            )
+        self.assertRaisesRegexp(
+            SyntaxError, "Mismatched end tag: 'for'",
+            self.try_render,
+            "{% if x %}X{% endfor %}", {}, ""
+            )