Commits

Ned Batchelder committed 78faac4

The name of the project is Coverage, not coverage.py.

  • Participants
  • Parent commits 5d45912

Comments (0)

Files changed (21)

-------------------------------
-CHANGE HISTORY for coverage.py
-------------------------------
+---------------------------
+Change history for Coverage
+---------------------------
 
-Version 3.0b2
--------------
+Version 3.0b2, 30 April 2009
+----------------------------
 
 HTML reporting, and continued refactoring.
 
 
 Major overhaul.
 
-- Coverage.py is now a package rather than a module, so the name is a bit of a
-  misnomer, since there is no longer a file named coverage.py.  Functionality
-  has been split into classes.
+- Coverage is now a package rather than a module.  Functionality has been split
+  into classes.
 
 - The trace function is implemented in C for speed.  Coverage runs are now
   much faster.
 
 - The singleton coverage object is only created if the module-level functions
   are used.  This maintains the old interface while allowing better
-  programmatic use of coverage.py.
+  programmatic use of Coverage.
   
 - The minimum supported Python version is 2.3.
  
-# Makefile for utility work on coverage.py
+# Makefile for utility work on Coverage.
 
 default:
 	@echo "* No default action *"
 Coverage: code coverage testing for Python
 
-Coverage.py is a Python package that measures code coverage 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 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.
 
 For more information, see http://nedbatchelder.com/code/modules/coverage.html
 The code is hosted at http://bitbucket.org/ned/coveragepy
+
 
 - Why can't you specify execute (-x) and report (-r) in the same invocation?
     Maybe just because -x needs the rest of the command line?
-- How will coverage.py package install over coverage.py module?
+- How will Coverage package install over coverage.py module?
 - Support 2.3 - 3.0?
     http://pythonology.blogspot.com/2009/02/making-code-run-on-python-20-through-30.html
-- Use a .coveragerc file to control coverage.py without the programmatic API.
+- Use a .coveragerc file to control Coverage without the programmatic API.
 - An inference mode that marks lines as executed if they "must have been" executed:
     class definitions, etc, when coverage is started after the class is defined.
 - Different categories of exclude pragma? So you can enable and disable them
 - Tests about parallel mode.
 + Tests about assigning a multi-line string.
 - Tests about tricky docstrings.
-- Coverage test coverage.py!
+- Coverage test Coverage!
 - Tests that tracing stops after calling stop()
 - More intensive thread testing.
 - Tests about the "import __main__" in cmdline.py

coverage/annotate.py

-"""Source file annotation for coverage.py"""
+"""Source file annotation for Coverage."""
 
 import os, re
 

coverage/cmdline.py

-"""Command-line support for coverage.py"""
+"""Command-line support for Coverage."""
 
 import getopt, sys
 
 
 
 class CoverageScript:
-    """The command-line interface to coverage.py"""
+    """The command-line interface to Coverage."""
     
     def __init__(self):
         import coverage
         self.coverage = coverage.coverage()
 
     def help(self, error=None):
-        """Display an error message, or the usage for coverage.py."""
+        """Display an error message, or the usage for Coverage."""
         if error:
             print error
             print "Use -h for help."
             print USAGE % self.covpkg.__dict__
 
     def command_line(self, argv, help_fn=None):
-        """The bulk of the command line interface to coverage.py.
+        """The bulk of the command line interface to Coverage.
         
         `argv` is the argument list to process.
         `help_fn` is the help function to use when something goes wrong.
     
 
 def main():
-    """The main entrypoint to coverage.py.
+    """The main entrypoint to Coverage.
     
     This is installed as the script entrypoint.
     

coverage/codeunit.py

-"""Code unit (module) handling for coverage.py"""
+"""Code unit (module) handling for Coverage."""
 
 import glob, os, types
 

coverage/collector.py

-"""Raw data collector for coverage.py."""
+"""Raw data collector for Coverage."""
 
 import sys, threading
 

coverage/control.py

-"""Core control stuff for coverage.py"""
+"""Core control stuff for Coverage."""
 
 import os, socket, sys
 
         self.sysprefix = self.file_locator.abs_file(sys.prefix)
         
         self.collector = Collector(self.should_trace)
-        self.data = CoverageData(collector="coverage.py v%s" % __version__)
+        self.data = CoverageData(collector="coverage v%s" % __version__)
     
         # The default exclude pattern.
         self.exclude('# *pragma[: ]*[nN][oO] *[cC][oO][vV][eE][rR]')
-"""Coverage data for coverage.py"""
+"""Coverage data for Coverage."""
 
 import os, types
 import cPickle as pickle
-"""HTML reporting for coverage.py"""
+"""HTML reporting for Coverage."""
 
 import os, re, shutil
 from coverage import __version__    # pylint: disable-msg=W0611

coverage/htmlfiles/index.html

 <div id='footer'>
     <div class='content'>
         <p>
-            <a class='nav' href='http://bitbucket.org/ned/coveragepy/'>coverage.py v{{__version__}}</a>
+            <a class='nav' href='http://bitbucket.org/ned/coveragepy/'>coverage v{{__version__}}</a>
         </p>
     </div>
 </div>

coverage/htmlfiles/style.css

-/* CSS styles for coverage.py */
+/* CSS styles for Coverage. */
 /* Page-wide styles */
 html, body, h1, h2, h3, p, td, th {
     margin: 0;
-"""Miscellaneous stuff for coverage.py"""
+"""Miscellaneous stuff for Coverage."""
 
 def nice_pair(pair):
     """Make a nice string representation of a pair of numbers.

coverage/parser.py

-"""Code parsing for coverage.py"""
+"""Code parsing for Coverage."""
 
 import re, token, tokenize, types
 import cStringIO as StringIO

coverage/report.py

-"""Reporter foundation for coverage.py"""
+"""Reporter foundation for Coverage."""
 
 import os
 from coverage.codeunit import code_unit_factory

coverage/tracer.c

-// C-based Tracer for coverage.py
+// C-based Tracer for Coverage.
 
 #include "Python.h"
 #include "compile.h"        // in 2.3, this wasn't part of Python.h
 
 """Code coverage testing for Python
 
-Coverage.py is a Python package that measures code coverage 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 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.
 """
 
 classifiers = """

test/coveragetest.py

     
     def checkCoverage(self, text, lines, missing="", excludes=None, report=""):
         # We write the code into a file so that we can import it.
-        # coverage.py wants to deal with things as modules with file names.
+        # Coverage wants to deal with things as modules with file names.
         modname = self.getModuleName()
         
         self.makeFile(modname, text)
 
-        # Start up coverage.py
+        # Start up Coverage.
         cov = coverage.coverage()
         cov.erase()
         for exc in excludes or []:
         # Import the python file, executing it.
         mod = self.importModule(modname)
         
-        # Stop coverage.py
+        # Stop Coverage.
         cov.stop()
 
         # Clean up our side effects

test/test_cmdline.py

 
 
 class CmdLineTest(CoverageTest):
-    """Tests of command-line processing for coverage.py."""
+    """Tests of command-line processing for Coverage."""
 
     def help_fn(self, error=None):
         raise Exception(error or "__doc__")

test/test_coverage.py

-# test coverage.py
+"""Tests for Coverage."""
 # Copyright 2004-2009, Ned Batchelder
 # http://nedbatchelder.com/code/modules/coverage.html