From b09acaa84c8624d67c9c1e271a780fbd2122c2c6 Mon Sep 17 00:00:00 2001
From: "rozza@x103086.gcapmedia.com" <rozza@x103086.gcapmedia.com>
Date: Fri, 20 Nov 2009 10:08:52 +0000
Subject: Moving file filter logic out so it can be monkey patched easily

---
 coverage/codeunit.py | 27 +++++++++++++++++----------
 1 file changed, 17 insertions(+), 10 deletions(-)

(limited to 'coverage')

diff --git a/coverage/codeunit.py b/coverage/codeunit.py
index e3107052..28fa0551 100644
--- a/coverage/codeunit.py
+++ b/coverage/codeunit.py
@@ -34,19 +34,26 @@ def code_unit_factory(morfs, file_locator, omit_prefixes=None):
     code_units = [CodeUnit(morf, file_locator) for morf in morfs]
     
     if omit_prefixes:
-        prefixes = [file_locator.abs_file(p) for p in omit_prefixes]
-        filtered = []
-        for cu in code_units:
-            for prefix in prefixes:
-                if cu.filename.startswith(prefix):
-                    break
-            else:
-                filtered.append(cu)
-    
-        code_units = filtered
+        code_units = omit_filter(omit_prefixes, code_units)
 
     return code_units
 
+def omit_filter(omit_prefixes, code_units):
+    """
+    The filtering method removing any unwanted code_units
+    
+    Refactored out so you can easily monkeypatch if needs be
+    """
+    prefixes = [file_locator.abs_file(p) for p in omit_prefixes]
+    filtered = []
+    for cu in code_units:
+        for prefix in prefixes:
+            if cu.filename.startswith(prefix):
+                break
+        else:
+            filtered.append(cu)
+            
+    return filtered
 
 class CodeUnit(object):
     """Code unit: a filename or module.
-- 
cgit v1.2.1


From cf2251822c220e4fc2a8f95f746dd269ac2659eb Mon Sep 17 00:00:00 2001
From: "rozza@x103086.gcapmedia.com" <rozza@x103086.gcapmedia.com>
Date: Fri, 20 Nov 2009 11:27:52 +0000
Subject: Adding a CoverageTestWrapper to be used by test runners / plugins.
 Added example plugins for pytest and nose Warning: I haven't tested the nose
 plugin against a test suite Warning: I use a file listing files / paths to
 omit from code coverage and use regexes to filter them out To ignore that
 remove the monkey patch..

---
 coverage/runner.py                       | 138 +++++++++++++++++++++++++++++++
 coverage/test_plugins/nose_coverage.py   | 111 +++++++++++++++++++++++++
 coverage/test_plugins/pytest_coverage.py |  69 ++++++++++++++++
 3 files changed, 318 insertions(+)
 create mode 100644 coverage/runner.py
 create mode 100644 coverage/test_plugins/nose_coverage.py
 create mode 100644 coverage/test_plugins/pytest_coverage.py

(limited to 'coverage')

diff --git a/coverage/runner.py b/coverage/runner.py
new file mode 100644
index 00000000..ce81b1c7
--- /dev/null
+++ b/coverage/runner.py
@@ -0,0 +1,138 @@
+import optparse
+
+class CoverageTestWrapper(object):
+    """
+    A Coverage Test Wrapper.
+    
+    1) Setup the with the parsed options
+    2) Call start()
+    3) Run your tests
+    4) Call finish()
+    5) Imporve your code coverage ;)
+    """
+    
+    def __init__(self, options, _covpkg=None):
+        self.options = options
+        
+        # _covpkg is for dependency injection, so we can test this code.
+        if _covpkg:
+            self.covpkg = _covpkg
+        else:
+            import coverage
+            self.covpkg = coverage
+        
+        self.coverage = None
+    
+    def start(self):
+        # Set up coverage
+        self.coverage = self.covpkg.coverage(
+            data_suffix = bool(self.options.cover_parallel_mode),
+            cover_pylib = self.options.cover_pylib,
+            timid = self.options.cover_timid,
+            branch = self.options.cover_branch,
+        )
+        
+        # Run the script.
+        self.coverage.start()
+        
+    def finish(self):
+        # end coverage and save the results
+        self.coverage.stop()
+        self.coverage.save()
+        
+        # Remaining actions are reporting, with some common self.options.
+        report_args = {
+            'morfs': [],
+            'ignore_errors': self.options.cover_ignore_errors,
+            }
+            
+        # Handle any omits
+        # Allow pointing to a file as well
+        try:
+            omit_file = open(self.options.cover_omit)
+            omit_prefixes = [line.strip() for line in omit_file.readlines()]
+            report_args['omit_prefixes'] = omit_prefixes
+        except:
+            omit = self.options.cover_omit.split(',')
+            report_args['omit_prefixes'] = omit
+        
+        if 'report' in self.options.cover_actions:
+            self.coverage.report(
+                show_missing=self.options.cover_show_missing, **report_args)
+        if 'annotate' in self.options.cover_actions:
+            self.coverage.annotate(
+                directory=self.options.cover_directory, **report_args)
+        if 'html' in self.options.cover_actions:
+            self.coverage.html_report(
+                directory=self.options.cover_directory, **report_args)
+        if 'xml' in self.options.cover_actions:
+            outfile = self.options.cover_outfile
+            if outfile == '-':
+                outfile = None
+            self.coverage.xml_report(outfile=outfile, **report_args)
+        
+        return
+
+class Options(object):
+    """A namespace class for individual options we'll build parsers from."""
+    
+    action = optparse.Option('',
+                '--cover-action', action='append', default=None,
+                dest='cover_actions', type="choice", choices=['annotate', 'html', 'report', 'xml'],
+                help="""
+                    annotate    Annotate source files with execution information.
+                    html        Create an HTML report.
+                    report      Report coverage stats on modules.
+                    xml         Create an XML report of coverage results.
+                """.strip())
+    
+    branch = optparse.Option(
+        '--cover-branch', action='store_true',
+        help="Measure branch execution. HIGHLY EXPERIMENTAL!"
+        )
+    directory = optparse.Option(
+        '--cover-directory', action='store',
+        metavar="DIR",
+        help="Write the output files to DIR."
+        )
+    ignore_errors = optparse.Option(
+        '--cover-ignore-errors', action='store_true',
+        help="Ignore errors while reading source files."
+        )
+    pylib = optparse.Option(
+        '--cover-pylib', action='store_true',
+        help="Measure coverage even inside the Python installed library, "
+                "which isn't done by default."
+        )
+    show_missing = optparse.Option(
+        '--cover-show-missing', action='store_true',
+        help="Show line numbers of statements in each module that weren't "
+                "executed."
+        )
+    omit = optparse.Option(
+        '--cover-omit', action='store',
+        metavar="PRE1,PRE2,...",
+        default='',
+        help="Omit files when their filename path starts with one of these "
+                "prefixes."
+        )
+    output_xml = optparse.Option(
+        '--cover-outfile', action='store',
+        metavar="OUTFILE",
+        help="Write the XML report to this file. Defaults to 'coverage.xml'"
+        )
+    parallel_mode = optparse.Option(
+        '--cover-parallel-mode', action='store_true',
+        help="Include the machine name and process id in the .coverage "
+                "data file name."
+        )
+    timid = optparse.Option(
+        '--cover-timid', action='store_true',
+        help="Use a simpler but slower trace method.  Try this if you get "
+                "seemingly impossible results!"
+        )
+    append = optparse.Option(
+        '--cover-append', action='store_false',
+        help="Append coverage data to .coverage, otherwise it is started "
+                "clean with each run."
+        )
diff --git a/coverage/test_plugins/nose_coverage.py b/coverage/test_plugins/nose_coverage.py
new file mode 100644
index 00000000..603ce43a
--- /dev/null
+++ b/coverage/test_plugins/nose_coverage.py
@@ -0,0 +1,111 @@
+import logging
+import unittest, os
+from nose.plugins import Plugin, PluginTester
+
+import sys
+import os
+sys.path.insert(0, os.path.realpath(os.path.join(os.path.dirname(__file__), '../../')))
+
+log = logging.getLogger(__name__)
+
+
+class Coverage(Plugin):
+    """
+    Activate a coverage report using Ned Batchelder's coverage module.
+    """
+    
+    name = "coverage_new"
+    score = 1
+    status = {}
+    
+    def options(self, parser, env):
+        """
+        Add options to command line.
+        """
+        
+        Plugin.options(self, parser, env)
+        
+        from coverage.runner import Options
+        # Loop the coverage options and append them to the plugin options
+        options = [a for a in dir(Options) if not a.startswith('_')]
+        for option in options:
+            opt = getattr(Options, option)
+            parser.add_option(opt)
+    
+    def configure(self, options, config):
+        """
+        Configure plugin.
+        """
+        try:
+            self.status.pop('active')
+        except KeyError:
+            pass
+        Plugin.configure(self, options, config)
+        if self.enabled:
+            try:
+                import coverage
+            except ImportError:
+                log.error("Coverage not available: "
+                          "unable to import coverage module")
+                self.enabled = False
+                return
+        
+        self.config = config
+        self.status['active'] = True
+        self.options = options
+        
+    def begin(self):
+        """
+        Begin recording coverage information.
+        """
+        log.debug("Coverage begin")
+        # Load the runner and start it up
+        from coverage.runner import CoverageTestWrapper
+        self.coverage = CoverageTestWrapper(self.options)
+        self.coverage.start()
+        
+    def report(self, stream):
+        """
+        Output code coverage report.
+        """
+        log.debug("Coverage report")
+        stream.write("Processing Coverage...")
+        # finish up with coverage
+        self.coverage.finish()
+
+
+# Monkey patch omit_filter to use regex patterns for file omits
+def omit_filter(omit_prefixes, code_units):
+    import re
+    exclude_patterns = [re.compile(line.strip()) for line in omit_prefixes if line and not line.startswith('#')]
+    filtered = []
+    for cu in code_units:
+        skip = False
+        for pattern in exclude_patterns:
+            if pattern.search(cu.filename):
+                skip = True
+                break
+            
+        if not skip:
+            filtered.append(cu)
+    return filtered
+
+try:
+    import coverage
+    coverage.codeunit.omit_filter = omit_filter
+except:
+    pass
+
+class TestCoverage(PluginTester, unittest.TestCase):
+    activate = '--with-coverage_new' # enables the plugin
+    plugins = [Coverage()]
+    args = ['--cover-action=report']
+    
+    def test_output(self):
+        assert "Processing Coverage..." in self.output, (
+                                        "got: %s" % self.output)
+    def makeSuite(self):
+        class TC(unittest.TestCase):
+            def runTest(self):
+                raise ValueError("Coverage down")
+        return unittest.TestSuite([TC()])
\ No newline at end of file
diff --git a/coverage/test_plugins/pytest_coverage.py b/coverage/test_plugins/pytest_coverage.py
new file mode 100644
index 00000000..5b910e94
--- /dev/null
+++ b/coverage/test_plugins/pytest_coverage.py
@@ -0,0 +1,69 @@
+"""
+Write and report coverage data with 'coverage.py'. 
+"""
+import py
+
+coverage = py.test.importorskip("coverage")
+
+def pytest_configure(config):
+    # Load the runner and start it up
+    from coverage.runner import CoverageTestWrapper
+    
+    config.coverage = CoverageTestWrapper(config.option)
+    config.coverage.start()
+
+def pytest_terminal_summary(terminalreporter):
+    # Finished the tests start processing the coverage
+    config = terminalreporter.config
+    tw = terminalreporter._tw
+    tw.sep('-', 'coverage')
+    tw.line('Processing Coverage...')
+    
+    # finish up with coverage
+    config.coverage.finish()
+
+def pytest_addoption(parser):
+    """
+    Get all the options from the coverage.runner and import them
+    """
+    from coverage.runner import Options
+    
+    group = parser.getgroup('Coverage options')
+    # Loop the coverage options and append them to the plugin options
+    options = [a for a in dir(Options) if not a.startswith('_')]
+    for option in options:
+        opt = getattr(Options, option)
+        group._addoption_instance(opt, shortupper=True)
+
+# Monkey patch omit_filter to use regex patterns for file omits
+def omit_filter(omit_prefixes, code_units):
+    import re
+    exclude_patterns = [re.compile(line.strip()) for line in omit_prefixes if line and not line.startswith('#')]
+    filtered = []
+    for cu in code_units:
+        skip = False
+        for pattern in exclude_patterns:
+            if pattern.search(cu.filename):
+                skip = True
+                break
+            
+        if not skip:
+            filtered.append(cu)
+    return filtered
+
+coverage.codeunit.omit_filter = omit_filter
+
+def test_functional(testdir):
+    py.test.importorskip("coverage")
+    testdir.plugins.append("coverage")
+    testdir.makepyfile("""
+        def f():    
+            x = 42
+        def test_whatever():
+            pass
+        """)
+    result = testdir.runpytest()
+    assert result.ret == 0
+    assert result.stdout.fnmatch_lines([
+        '*Processing Coverage*'
+        ])
\ No newline at end of file
-- 
cgit v1.2.1


From 7ef0b6926536b39cda0b659e3d814585b873fa9e Mon Sep 17 00:00:00 2001
From: "rozza@x103086.gcapmedia.com" <rozza@x103086.gcapmedia.com>
Date: Fri, 20 Nov 2009 11:54:30 +0000
Subject: Typo

---
 coverage/runner.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'coverage')

diff --git a/coverage/runner.py b/coverage/runner.py
index ce81b1c7..ba4861a7 100644
--- a/coverage/runner.py
+++ b/coverage/runner.py
@@ -8,7 +8,7 @@ class CoverageTestWrapper(object):
     2) Call start()
     3) Run your tests
     4) Call finish()
-    5) Imporve your code coverage ;)
+    5) Improve your code coverage ;)
     """
     
     def __init__(self, options, _covpkg=None):
-- 
cgit v1.2.1


From 66e3cb2383ce60793559453ad3243f70d38d94a1 Mon Sep 17 00:00:00 2001
From: holger krekel <holger@merlinux.eu>
Date: Wed, 25 Nov 2009 18:08:57 +0100
Subject: * move pytest_coverage/nose_plugin to become directly importable *
 fixing order of coverage options * pytest: only do coverage-processing if
 cover-action is defined

--HG--
rename : coverage/test_plugins/nose_coverage.py => coverage/nose_coverage.py
rename : coverage/test_plugins/pytest_coverage.py => coverage/pytest_coverage.py
---
 coverage/nose_coverage.py                | 106 +++++++++++++++++++++++++++++
 coverage/pytest_coverage.py              |  74 +++++++++++++++++++++
 coverage/runner.py                       |  60 ++++++++---------
 coverage/test_plugins/nose_coverage.py   | 111 -------------------------------
 coverage/test_plugins/pytest_coverage.py |  69 -------------------
 5 files changed, 210 insertions(+), 210 deletions(-)
 create mode 100644 coverage/nose_coverage.py
 create mode 100644 coverage/pytest_coverage.py
 delete mode 100644 coverage/test_plugins/nose_coverage.py
 delete mode 100644 coverage/test_plugins/pytest_coverage.py

(limited to 'coverage')

diff --git a/coverage/nose_coverage.py b/coverage/nose_coverage.py
new file mode 100644
index 00000000..6ba0a104
--- /dev/null
+++ b/coverage/nose_coverage.py
@@ -0,0 +1,106 @@
+import logging
+import unittest, os
+from nose.plugins import Plugin, PluginTester
+
+import sys
+import os
+sys.path.insert(0, os.path.realpath(os.path.join(os.path.dirname(__file__), '../../')))
+
+log = logging.getLogger(__name__)
+
+
+class Coverage(Plugin):
+    """
+    Activate a coverage report using Ned Batchelder's coverage module.
+    """
+    
+    name = "coverage_new"
+    score = 1
+    status = {}
+    
+    def options(self, parser, env):
+        """
+        Add options to command line.
+        """
+        Plugin.options(self, parser, env)
+        from coverage.runner import options
+        for opt in options:
+            parser.add_option(opt)
+    
+    def configure(self, options, config):
+        """
+        Configure plugin.
+        """
+        try:
+            self.status.pop('active')
+        except KeyError:
+            pass
+        Plugin.configure(self, options, config)
+        if self.enabled:
+            try:
+                import coverage
+            except ImportError:
+                log.error("Coverage not available: "
+                          "unable to import coverage module")
+                self.enabled = False
+                return
+        
+        self.config = config
+        self.status['active'] = True
+        self.options = options
+        
+    def begin(self):
+        """
+        Begin recording coverage information.
+        """
+        log.debug("Coverage begin")
+        # Load the runner and start it up
+        from coverage.runner import CoverageTestWrapper
+        self.coverage = CoverageTestWrapper(self.options)
+        self.coverage.start()
+        
+    def report(self, stream):
+        """
+        Output code coverage report.
+        """
+        log.debug("Coverage report")
+        stream.write("Processing Coverage...")
+        # finish up with coverage
+        self.coverage.finish()
+
+
+# Monkey patch omit_filter to use regex patterns for file omits
+def omit_filter(omit_prefixes, code_units):
+    import re
+    exclude_patterns = [re.compile(line.strip()) for line in omit_prefixes if line and not line.startswith('#')]
+    filtered = []
+    for cu in code_units:
+        skip = False
+        for pattern in exclude_patterns:
+            if pattern.search(cu.filename):
+                skip = True
+                break
+            
+        if not skip:
+            filtered.append(cu)
+    return filtered
+
+try:
+    import coverage
+    coverage.codeunit.omit_filter = omit_filter
+except:
+    pass
+
+class TestCoverage(PluginTester, unittest.TestCase):
+    activate = '--with-coverage_new' # enables the plugin
+    plugins = [Coverage()]
+    args = ['--cover-action=report']
+    
+    def test_output(self):
+        assert "Processing Coverage..." in self.output, (
+                                        "got: %s" % self.output)
+    def makeSuite(self):
+        class TC(unittest.TestCase):
+            def runTest(self):
+                raise ValueError("Coverage down")
+        return unittest.TestSuite([TC()])
diff --git a/coverage/pytest_coverage.py b/coverage/pytest_coverage.py
new file mode 100644
index 00000000..094be44a
--- /dev/null
+++ b/coverage/pytest_coverage.py
@@ -0,0 +1,74 @@
+"""
+Write and report coverage data with 'coverage.py'. 
+"""
+import py
+import coverage
+
+def pytest_addoption(parser):
+    """
+    Get all the options from the coverage.runner and import them
+    """
+    from coverage.runner import options
+    group = parser.getgroup('Coverage options')
+    for opt in options:
+        group._addoption_instance(opt)
+
+def pytest_configure(config):
+    # Load the runner and start it up
+    if config.getvalue("cover_actions"):
+        config.pluginmanager.register(DoCover(config), "do_coverage")
+
+class DoCover:
+    def __init__(self, config):
+        self.config = config
+
+    def pytest_sessionstart(self):
+        from coverage.runner import CoverageTestWrapper
+        self.coverage = CoverageTestWrapper(self.config.option)
+        # XXX maybe better to start/suspend/resume coverage
+        # for each single test item
+        self.coverage.start()
+
+    def pytest_terminal_summary(self, terminalreporter):
+        # Finished the tests start processing the coverage
+        config = terminalreporter.config
+        tw = terminalreporter._tw
+        tw.sep('-', 'coverage')
+        tw.line('Processing Coverage...')
+        self.coverage.finish()
+       
+
+# Monkey patch omit_filter to use regex patterns for file omits
+def omit_filter(omit_prefixes, code_units):
+    import re
+    exclude_patterns = [re.compile(line.strip()) for line in omit_prefixes if line and not line.startswith('#')]
+    filtered = []
+    for cu in code_units:
+        skip = False
+        for pattern in exclude_patterns:
+            if pattern.search(cu.filename):
+                skip = True
+                break
+            
+        if not skip:
+            filtered.append(cu)
+    return filtered
+
+coverage.codeunit.omit_filter = omit_filter
+
+pytest_plugins = ['pytester']
+def test_functional(testdir):
+    testdir.makepyfile("""
+        def f():    
+            x = 42
+        def test_whatever():
+            pass
+        """)
+    result = testdir.runpytest("--cover-action=annotate")
+    assert result.ret == 0
+    assert result.stdout.fnmatch_lines([
+        '*Processing Coverage*'
+        ])
+    coveragefile = testdir.tmpdir.join(".coverage")
+    assert coveragefile.check()
+    # XXX try loading it? 
diff --git a/coverage/runner.py b/coverage/runner.py
index ba4861a7..ef4c1f21 100644
--- a/coverage/runner.py
+++ b/coverage/runner.py
@@ -73,66 +73,66 @@ class CoverageTestWrapper(object):
         
         return
 
-class Options(object):
-    """A namespace class for individual options we'll build parsers from."""
-    
-    action = optparse.Option('',
+options = [
+    optparse.Option('',
                 '--cover-action', action='append', default=None,
                 dest='cover_actions', type="choice", choices=['annotate', 'html', 'report', 'xml'],
-                help="""
-                    annotate    Annotate source files with execution information.
-                    html        Create an HTML report.
-                    report      Report coverage stats on modules.
-                    xml         Create an XML report of coverage results.
-                """.strip())
-    
-    branch = optparse.Option(
+                help="""\
+annotate    Annotate source files with execution information.
+html        Create an HTML report.
+report      Report coverage stats on modules.
+xml         Create an XML report of coverage results.
+""".strip()),
+
+    optparse.Option(
         '--cover-branch', action='store_true',
         help="Measure branch execution. HIGHLY EXPERIMENTAL!"
-        )
-    directory = optparse.Option(
+        ),
+    optparse.Option(
         '--cover-directory', action='store',
         metavar="DIR",
         help="Write the output files to DIR."
-        )
-    ignore_errors = optparse.Option(
+        ),
+    optparse.Option(
         '--cover-ignore-errors', action='store_true',
         help="Ignore errors while reading source files."
-        )
-    pylib = optparse.Option(
+        ),
+    optparse.Option(
         '--cover-pylib', action='store_true',
         help="Measure coverage even inside the Python installed library, "
                 "which isn't done by default."
-        )
-    show_missing = optparse.Option(
+        ),
+    optparse.Option(
         '--cover-show-missing', action='store_true',
         help="Show line numbers of statements in each module that weren't "
                 "executed."
-        )
-    omit = optparse.Option(
+        ),
+    optparse.Option(
         '--cover-omit', action='store',
         metavar="PRE1,PRE2,...",
         default='',
         help="Omit files when their filename path starts with one of these "
                 "prefixes."
-        )
-    output_xml = optparse.Option(
+        ),
+    optparse.Option(
         '--cover-outfile', action='store',
         metavar="OUTFILE",
         help="Write the XML report to this file. Defaults to 'coverage.xml'"
-        )
-    parallel_mode = optparse.Option(
+        ),
+    optparse.Option(
         '--cover-parallel-mode', action='store_true',
         help="Include the machine name and process id in the .coverage "
                 "data file name."
-        )
-    timid = optparse.Option(
+        ),
+    optparse.Option(
         '--cover-timid', action='store_true',
         help="Use a simpler but slower trace method.  Try this if you get "
                 "seemingly impossible results!"
-        )
-    append = optparse.Option(
+        ),
+    optparse.Option(
         '--cover-append', action='store_false',
         help="Append coverage data to .coverage, otherwise it is started "
                 "clean with each run."
         )
+]
+
diff --git a/coverage/test_plugins/nose_coverage.py b/coverage/test_plugins/nose_coverage.py
deleted file mode 100644
index 603ce43a..00000000
--- a/coverage/test_plugins/nose_coverage.py
+++ /dev/null
@@ -1,111 +0,0 @@
-import logging
-import unittest, os
-from nose.plugins import Plugin, PluginTester
-
-import sys
-import os
-sys.path.insert(0, os.path.realpath(os.path.join(os.path.dirname(__file__), '../../')))
-
-log = logging.getLogger(__name__)
-
-
-class Coverage(Plugin):
-    """
-    Activate a coverage report using Ned Batchelder's coverage module.
-    """
-    
-    name = "coverage_new"
-    score = 1
-    status = {}
-    
-    def options(self, parser, env):
-        """
-        Add options to command line.
-        """
-        
-        Plugin.options(self, parser, env)
-        
-        from coverage.runner import Options
-        # Loop the coverage options and append them to the plugin options
-        options = [a for a in dir(Options) if not a.startswith('_')]
-        for option in options:
-            opt = getattr(Options, option)
-            parser.add_option(opt)
-    
-    def configure(self, options, config):
-        """
-        Configure plugin.
-        """
-        try:
-            self.status.pop('active')
-        except KeyError:
-            pass
-        Plugin.configure(self, options, config)
-        if self.enabled:
-            try:
-                import coverage
-            except ImportError:
-                log.error("Coverage not available: "
-                          "unable to import coverage module")
-                self.enabled = False
-                return
-        
-        self.config = config
-        self.status['active'] = True
-        self.options = options
-        
-    def begin(self):
-        """
-        Begin recording coverage information.
-        """
-        log.debug("Coverage begin")
-        # Load the runner and start it up
-        from coverage.runner import CoverageTestWrapper
-        self.coverage = CoverageTestWrapper(self.options)
-        self.coverage.start()
-        
-    def report(self, stream):
-        """
-        Output code coverage report.
-        """
-        log.debug("Coverage report")
-        stream.write("Processing Coverage...")
-        # finish up with coverage
-        self.coverage.finish()
-
-
-# Monkey patch omit_filter to use regex patterns for file omits
-def omit_filter(omit_prefixes, code_units):
-    import re
-    exclude_patterns = [re.compile(line.strip()) for line in omit_prefixes if line and not line.startswith('#')]
-    filtered = []
-    for cu in code_units:
-        skip = False
-        for pattern in exclude_patterns:
-            if pattern.search(cu.filename):
-                skip = True
-                break
-            
-        if not skip:
-            filtered.append(cu)
-    return filtered
-
-try:
-    import coverage
-    coverage.codeunit.omit_filter = omit_filter
-except:
-    pass
-
-class TestCoverage(PluginTester, unittest.TestCase):
-    activate = '--with-coverage_new' # enables the plugin
-    plugins = [Coverage()]
-    args = ['--cover-action=report']
-    
-    def test_output(self):
-        assert "Processing Coverage..." in self.output, (
-                                        "got: %s" % self.output)
-    def makeSuite(self):
-        class TC(unittest.TestCase):
-            def runTest(self):
-                raise ValueError("Coverage down")
-        return unittest.TestSuite([TC()])
\ No newline at end of file
diff --git a/coverage/test_plugins/pytest_coverage.py b/coverage/test_plugins/pytest_coverage.py
deleted file mode 100644
index 5b910e94..00000000
--- a/coverage/test_plugins/pytest_coverage.py
+++ /dev/null
@@ -1,69 +0,0 @@
-"""
-Write and report coverage data with 'coverage.py'. 
-"""
-import py
-
-coverage = py.test.importorskip("coverage")
-
-def pytest_configure(config):
-    # Load the runner and start it up
-    from coverage.runner import CoverageTestWrapper
-    
-    config.coverage = CoverageTestWrapper(config.option)
-    config.coverage.start()
-
-def pytest_terminal_summary(terminalreporter):
-    # Finished the tests start processing the coverage
-    config = terminalreporter.config
-    tw = terminalreporter._tw
-    tw.sep('-', 'coverage')
-    tw.line('Processing Coverage...')
-    
-    # finish up with coverage
-    config.coverage.finish()
-
-def pytest_addoption(parser):
-    """
-    Get all the options from the coverage.runner and import them
-    """
-    from coverage.runner import Options
-    
-    group = parser.getgroup('Coverage options')
-    # Loop the coverage options and append them to the plugin options
-    options = [a for a in dir(Options) if not a.startswith('_')]
-    for option in options:
-        opt = getattr(Options, option)
-        group._addoption_instance(opt, shortupper=True)
-
-# Monkey patch omit_filter to use regex patterns for file omits
-def omit_filter(omit_prefixes, code_units):
-    import re
-    exclude_patterns = [re.compile(line.strip()) for line in omit_prefixes if line and not line.startswith('#')]
-    filtered = []
-    for cu in code_units:
-        skip = False
-        for pattern in exclude_patterns:
-            if pattern.search(cu.filename):
-                skip = True
-                break
-            
-        if not skip:
-            filtered.append(cu)
-    return filtered
-
-coverage.codeunit.omit_filter = omit_filter
-
-def test_functional(testdir):
-    py.test.importorskip("coverage")
-    testdir.plugins.append("coverage")
-    testdir.makepyfile("""
-        def f():    
-            x = 42
-        def test_whatever():
-            pass
-        """)
-    result = testdir.runpytest()
-    assert result.ret == 0
-    assert result.stdout.fnmatch_lines([
-        '*Processing Coverage*'
-        ])
\ No newline at end of file
-- 
cgit v1.2.1


From b61370af5615d8aa781f1d311fe408e9a036b6da Mon Sep 17 00:00:00 2001
From: holger krekel <holger@merlinux.eu>
Date: Wed, 25 Nov 2009 18:56:24 +0100
Subject: merging/unifying test plugin code * coverage/testplugin.py contains
 common test plugin options   and pytest hooks (which don't induce "import
 py") * coverage/nose_coverage.py contains a basic Nose Plugin *
 test/test_testplugin.py contains a pytest-functional test   and a
 nose-skeleton one.  skipped as appropriate.

--HG--
rename : coverage/runner.py => coverage/testplugin.py
---
 coverage/nose_coverage.py   |  44 +---------
 coverage/pytest_coverage.py |  74 -----------------
 coverage/runner.py          | 138 --------------------------------
 coverage/testplugin.py      | 190 ++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 193 insertions(+), 253 deletions(-)
 delete mode 100644 coverage/pytest_coverage.py
 delete mode 100644 coverage/runner.py
 create mode 100644 coverage/testplugin.py

(limited to 'coverage')

diff --git a/coverage/nose_coverage.py b/coverage/nose_coverage.py
index 6ba0a104..907e6803 100644
--- a/coverage/nose_coverage.py
+++ b/coverage/nose_coverage.py
@@ -1,10 +1,9 @@
 import logging
 import unittest, os
-from nose.plugins import Plugin, PluginTester
-
+from nose.plugins import Plugin
 import sys
-import os
-sys.path.insert(0, os.path.realpath(os.path.join(os.path.dirname(__file__), '../../')))
+
+from coverage.testplugin import CoverageTestWrapper
 
 log = logging.getLogger(__name__)
 
@@ -55,7 +54,6 @@ class Coverage(Plugin):
         """
         log.debug("Coverage begin")
         # Load the runner and start it up
-        from coverage.runner import CoverageTestWrapper
         self.coverage = CoverageTestWrapper(self.options)
         self.coverage.start()
         
@@ -68,39 +66,3 @@ class Coverage(Plugin):
         # finish up with coverage
         self.coverage.finish()
 
-
-# Monkey patch omit_filter to use regex patterns for file omits
-def omit_filter(omit_prefixes, code_units):
-    import re
-    exclude_patterns = [re.compile(line.strip()) for line in omit_prefixes if line and not line.startswith('#')]
-    filtered = []
-    for cu in code_units:
-        skip = False
-        for pattern in exclude_patterns:
-            if pattern.search(cu.filename):
-                skip = True
-                break
-            
-        if not skip:
-            filtered.append(cu)
-    return filtered
-
-try:
-    import coverage
-    coverage.codeunit.omit_filter = omit_filter
-except:
-    pass
-
-class TestCoverage(PluginTester, unittest.TestCase):
-    activate = '--with-coverage_new' # enables the plugin
-    plugins = [Coverage()]
-    args = ['--cover-action=report']
-    
-    def test_output(self):
-        assert "Processing Coverage..." in self.output, (
-                                        "got: %s" % self.output)
-    def makeSuite(self):
-        class TC(unittest.TestCase):
-            def runTest(self):
-                raise ValueError("Coverage down")
-        return unittest.TestSuite([TC()])
diff --git a/coverage/pytest_coverage.py b/coverage/pytest_coverage.py
deleted file mode 100644
index 094be44a..00000000
--- a/coverage/pytest_coverage.py
+++ /dev/null
@@ -1,74 +0,0 @@
-"""
-Write and report coverage data with 'coverage.py'. 
-"""
-import py
-import coverage
-
-def pytest_addoption(parser):
-    """
-    Get all the options from the coverage.runner and import them
-    """
-    from coverage.runner import options
-    group = parser.getgroup('Coverage options')
-    for opt in options:
-        group._addoption_instance(opt)
-
-def pytest_configure(config):
-    # Load the runner and start it up
-    if config.getvalue("cover_actions"):
-        config.pluginmanager.register(DoCover(config), "do_coverage")
-
-class DoCover:
-    def __init__(self, config):
-        self.config = config
-
-    def pytest_sessionstart(self):
-        from coverage.runner import CoverageTestWrapper
-        self.coverage = CoverageTestWrapper(self.config.option)
-        # XXX maybe better to start/suspend/resume coverage
-        # for each single test item
-        self.coverage.start()
-
-    def pytest_terminal_summary(self, terminalreporter):
-        # Finished the tests start processing the coverage
-        config = terminalreporter.config
-        tw = terminalreporter._tw
-        tw.sep('-', 'coverage')
-        tw.line('Processing Coverage...')
-        self.coverage.finish()
-       
-
-# Monkey patch omit_filter to use regex patterns for file omits
-def omit_filter(omit_prefixes, code_units):
-    import re
-    exclude_patterns = [re.compile(line.strip()) for line in omit_prefixes if line and not line.startswith('#')]
-    filtered = []
-    for cu in code_units:
-        skip = False
-        for pattern in exclude_patterns:
-            if pattern.search(cu.filename):
-                skip = True
-                break
-            
-        if not skip:
-            filtered.append(cu)
-    return filtered
-
-coverage.codeunit.omit_filter = omit_filter
-
-pytest_plugins = ['pytester']
-def test_functional(testdir):
-    testdir.makepyfile("""
-        def f():    
-            x = 42
-        def test_whatever():
-            pass
-        """)
-    result = testdir.runpytest("--cover-action=annotate")
-    assert result.ret == 0
-    assert result.stdout.fnmatch_lines([
-        '*Processing Coverage*'
-        ])
-    coveragefile = testdir.tmpdir.join(".coverage")
-    assert coveragefile.check()
-    # XXX try loading it? 
diff --git a/coverage/runner.py b/coverage/runner.py
deleted file mode 100644
index ef4c1f21..00000000
--- a/coverage/runner.py
+++ /dev/null
@@ -1,138 +0,0 @@
-import optparse
-
-class CoverageTestWrapper(object):
-    """
-    A Coverage Test Wrapper.
-    
-    1) Setup the with the parsed options
-    2) Call start()
-    3) Run your tests
-    4) Call finish()
-    5) Improve your code coverage ;)
-    """
-    
-    def __init__(self, options, _covpkg=None):
-        self.options = options
-        
-        # _covpkg is for dependency injection, so we can test this code.
-        if _covpkg:
-            self.covpkg = _covpkg
-        else:
-            import coverage
-            self.covpkg = coverage
-        
-        self.coverage = None
-    
-    def start(self):
-        # Set up coverage
-        self.coverage = self.covpkg.coverage(
-            data_suffix = bool(self.options.cover_parallel_mode),
-            cover_pylib = self.options.cover_pylib,
-            timid = self.options.cover_timid,
-            branch = self.options.cover_branch,
-        )
-        
-        # Run the script.
-        self.coverage.start()
-        
-    def finish(self):
-        # end coverage and save the results
-        self.coverage.stop()
-        self.coverage.save()
-        
-        # Remaining actions are reporting, with some common self.options.
-        report_args = {
-            'morfs': [],
-            'ignore_errors': self.options.cover_ignore_errors,
-            }
-            
-        # Handle any omits
-        # Allow pointing to a file as well
-        try:
-            omit_file = open(self.options.cover_omit)
-            omit_prefixes = [line.strip() for line in omit_file.readlines()]
-            report_args['omit_prefixes'] = omit_prefixes
-        except:
-            omit = self.options.cover_omit.split(',')
-            report_args['omit_prefixes'] = omit
-        
-        if 'report' in self.options.cover_actions:
-            self.coverage.report(
-                show_missing=self.options.cover_show_missing, **report_args)
-        if 'annotate' in self.options.cover_actions:
-            self.coverage.annotate(
-                directory=self.options.cover_directory, **report_args)
-        if 'html' in self.options.cover_actions:
-            self.coverage.html_report(
-                directory=self.options.cover_directory, **report_args)
-        if 'xml' in self.options.cover_actions:
-            outfile = self.options.cover_outfile
-            if outfile == '-':
-                outfile = None
-            self.coverage.xml_report(outfile=outfile, **report_args)
-        
-        return
-
-options = [
-    optparse.Option('',
-                '--cover-action', action='append', default=None,
-                dest='cover_actions', type="choice", choices=['annotate', 'html', 'report', 'xml'],
-                help="""\
-annotate    Annotate source files with execution information.
-html        Create an HTML report.
-report      Report coverage stats on modules.
-xml         Create an XML report of coverage results.
-""".strip()),
-
-    optparse.Option(
-        '--cover-branch', action='store_true',
-        help="Measure branch execution. HIGHLY EXPERIMENTAL!"
-        ),
-    optparse.Option(
-        '--cover-directory', action='store',
-        metavar="DIR",
-        help="Write the output files to DIR."
-        ),
-    optparse.Option(
-        '--cover-ignore-errors', action='store_true',
-        help="Ignore errors while reading source files."
-        ),
-    optparse.Option(
-        '--cover-pylib', action='store_true',
-        help="Measure coverage even inside the Python installed library, "
-                "which isn't done by default."
-        ),
-    optparse.Option(
-        '--cover-show-missing', action='store_true',
-        help="Show line numbers of statements in each module that weren't "
-                "executed."
-        ),
-    optparse.Option(
-        '--cover-omit', action='store',
-        metavar="PRE1,PRE2,...",
-        default='',
-        help="Omit files when their filename path starts with one of these "
-                "prefixes."
-        ),
-    optparse.Option(
-        '--cover-outfile', action='store',
-        metavar="OUTFILE",
-        help="Write the XML report to this file. Defaults to 'coverage.xml'"
-        ),
-    optparse.Option(
-        '--cover-parallel-mode', action='store_true',
-        help="Include the machine name and process id in the .coverage "
-                "data file name."
-        ),
-    optparse.Option(
-        '--cover-timid', action='store_true',
-        help="Use a simpler but slower trace method.  Try this if you get "
-                "seemingly impossible results!"
-        ),
-    optparse.Option(
-        '--cover-append', action='store_false',
-        help="Append coverage data to .coverage, otherwise it is started "
-                "clean with each run."
-        )
-]
-
diff --git a/coverage/testplugin.py b/coverage/testplugin.py
new file mode 100644
index 00000000..a979ad2b
--- /dev/null
+++ b/coverage/testplugin.py
@@ -0,0 +1,190 @@
+import coverage, optparse
+
+class CoverageTestWrapper(object):
+    """
+    A Coverage Test Wrapper.
+    
+    1) Setup the with the parsed options
+    2) Call start()
+    3) Run your tests
+    4) Call finish()
+    5) Improve your code coverage ;)
+    """
+    
+    def __init__(self, options, _covpkg=None):
+        self.options = options
+        
+        # _covpkg is for dependency injection, so we can test this code.
+        if _covpkg:
+            self.covpkg = _covpkg
+        else:
+            import coverage
+            self.covpkg = coverage
+        
+        self.coverage = None
+    
+    def start(self):
+        # Set up coverage
+        self.coverage = self.covpkg.coverage(
+            data_suffix = bool(self.options.cover_parallel_mode),
+            cover_pylib = self.options.cover_pylib,
+            timid = self.options.cover_timid,
+            branch = self.options.cover_branch,
+        )
+        
+        # Run the script.
+        self.coverage.start()
+        
+    def finish(self):
+        # end coverage and save the results
+        self.coverage.stop()
+        self.coverage.save()
+        
+        # Remaining actions are reporting, with some common self.options.
+        report_args = {
+            'morfs': [],
+            'ignore_errors': self.options.cover_ignore_errors,
+            }
+            
+        # Handle any omits
+        # Allow pointing to a file as well
+        try:
+            omit_file = open(self.options.cover_omit)
+            omit_prefixes = [line.strip() for line in omit_file.readlines()]
+            report_args['omit_prefixes'] = omit_prefixes
+        except:
+            omit = self.options.cover_omit.split(',')
+            report_args['omit_prefixes'] = omit
+        
+        if 'report' in self.options.cover_actions:
+            self.coverage.report(
+                show_missing=self.options.cover_show_missing, **report_args)
+        if 'annotate' in self.options.cover_actions:
+            self.coverage.annotate(
+                directory=self.options.cover_directory, **report_args)
+        if 'html' in self.options.cover_actions:
+            self.coverage.html_report(
+                directory=self.options.cover_directory, **report_args)
+        if 'xml' in self.options.cover_actions:
+            outfile = self.options.cover_outfile
+            if outfile == '-':
+                outfile = None
+            self.coverage.xml_report(outfile=outfile, **report_args)
+        
+        return
+
+options = [
+    optparse.Option('',
+                '--cover-action', action='append', default=None,
+                dest='cover_actions', type="choice", choices=['annotate', 'html', 'report', 'xml'],
+                help="""\
+annotate    Annotate source files with execution information.
+html        Create an HTML report.
+report      Report coverage stats on modules.
+xml         Create an XML report of coverage results.
+""".strip()),
+
+    optparse.Option(
+        '--cover-branch', action='store_true',
+        help="Measure branch execution. HIGHLY EXPERIMENTAL!"
+        ),
+    optparse.Option(
+        '--cover-directory', action='store',
+        metavar="DIR",
+        help="Write the output files to DIR."
+        ),
+    optparse.Option(
+        '--cover-ignore-errors', action='store_true',
+        help="Ignore errors while reading source files."
+        ),
+    optparse.Option(
+        '--cover-pylib', action='store_true',
+        help="Measure coverage even inside the Python installed library, "
+                "which isn't done by default."
+        ),
+    optparse.Option(
+        '--cover-show-missing', action='store_true',
+        help="Show line numbers of statements in each module that weren't "
+                "executed."
+        ),
+    optparse.Option(
+        '--cover-omit', action='store',
+        metavar="PRE1,PRE2,...",
+        default='',
+        help="Omit files when their filename path starts with one of these "
+                "prefixes."
+        ),
+    optparse.Option(
+        '--cover-outfile', action='store',
+        metavar="OUTFILE",
+        help="Write the XML report to this file. Defaults to 'coverage.xml'"
+        ),
+    optparse.Option(
+        '--cover-parallel-mode', action='store_true',
+        help="Include the machine name and process id in the .coverage "
+                "data file name."
+        ),
+    optparse.Option(
+        '--cover-timid', action='store_true',
+        help="Use a simpler but slower trace method.  Try this if you get "
+                "seemingly impossible results!"
+        ),
+    optparse.Option(
+        '--cover-append', action='store_false',
+        help="Append coverage data to .coverage, otherwise it is started "
+                "clean with each run."
+        )
+]
+
+# py.test plugin hooks
+
+def pytest_addoption(parser):
+    """
+    Get all the options from the coverage.runner and import them
+    """
+    group = parser.getgroup('Coverage options')
+    for opt in options:
+        group._addoption_instance(opt)
+
+def pytest_configure(config):
+    # Load the runner and start it up
+    if config.getvalue("cover_actions"):
+        config.pluginmanager.register(DoCover(config), "do_coverage")
+
+class DoCover:
+    def __init__(self, config):
+        self.config = config
+
+    def pytest_sessionstart(self):
+        self.coverage = CoverageTestWrapper(self.config.option)
+        # XXX maybe better to start/suspend/resume coverage
+        # for each single test item
+        self.coverage.start()
+
+    def pytest_terminal_summary(self, terminalreporter):
+        # Finished the tests start processing the coverage
+        config = terminalreporter.config
+        tw = terminalreporter._tw
+        tw.sep('-', 'coverage')
+        tw.line('Processing Coverage...')
+        self.coverage.finish()
+       
+
+# XXX please make the following unnessary
+# Monkey patch omit_filter to use regex patterns for file omits
+def omit_filter(omit_prefixes, code_units):
+    import re
+    exclude_patterns = [re.compile(line.strip()) for line in omit_prefixes if line and not line.startswith('#')]
+    filtered = []
+    for cu in code_units:
+        skip = False
+        for pattern in exclude_patterns:
+            if pattern.search(cu.filename):
+                skip = True
+                break
+            
+        if not skip:
+            filtered.append(cu)
+    return filtered
+
+coverage.codeunit.omit_filter = omit_filter
-- 
cgit v1.2.1


From 00bb4d47c7dddfb7bcfe5d18b47e70f3c1648659 Mon Sep 17 00:00:00 2001
From: holger krekel <holger@merlinux.eu>
Date: Wed, 10 Feb 2010 18:23:18 +0100
Subject: integrate a patch by prologic (James Mills) to add some options.

---
 coverage/testplugin.py | 36 ++++++++++++++++++++++++++++++++----
 1 file changed, 32 insertions(+), 4 deletions(-)

(limited to 'coverage')

diff --git a/coverage/testplugin.py b/coverage/testplugin.py
index a979ad2b..7b8c0f43 100644
--- a/coverage/testplugin.py
+++ b/coverage/testplugin.py
@@ -1,4 +1,10 @@
-import coverage, optparse
+import os
+import re
+import sys
+import optparse
+from types import ListType
+
+import coverage
 
 class CoverageTestWrapper(object):
     """
@@ -11,6 +17,9 @@ class CoverageTestWrapper(object):
     5) Improve your code coverage ;)
     """
     
+    coverTests = False
+    coverPackages = None
+
     def __init__(self, options, _covpkg=None):
         self.options = options
         
@@ -22,6 +31,9 @@ class CoverageTestWrapper(object):
             self.covpkg = coverage
         
         self.coverage = None
+
+        self.coverTests = options.cover_tests
+        self.coverPackage = options.cover_package
     
     def start(self):
         # Set up coverage
@@ -31,6 +43,8 @@ class CoverageTestWrapper(object):
             timid = self.options.cover_timid,
             branch = self.options.cover_branch,
         )
+
+        self.skipModules = sys.modules.keys()[:]
         
         # Run the script.
         self.coverage.start()
@@ -39,10 +53,14 @@ class CoverageTestWrapper(object):
         # end coverage and save the results
         self.coverage.stop()
         self.coverage.save()
+
+        modules = [module
+                for name, module in sys.modules.items()
+                if module is not None and name.startswith(self.coverPackage)]
         
         # Remaining actions are reporting, with some common self.options.
         report_args = {
-            'morfs': [],
+            'morfs': modules,
             'ignore_errors': self.options.cover_ignore_errors,
             }
             
@@ -55,7 +73,7 @@ class CoverageTestWrapper(object):
         except:
             omit = self.options.cover_omit.split(',')
             report_args['omit_prefixes'] = omit
-        
+
         if 'report' in self.options.cover_actions:
             self.coverage.report(
                 show_missing=self.options.cover_show_missing, **report_args)
@@ -83,7 +101,17 @@ html        Create an HTML report.
 report      Report coverage stats on modules.
 xml         Create an XML report of coverage results.
 """.strip()),
-
+    optparse.Option(
+        '--cover-package', action='store',
+        dest="cover_package",
+        metavar="COVER_PACKAGE",
+        help="Restrict coverage output to selected package"
+        ),
+    optparse.Option("--cover-tests", action="store_true",
+        dest="cover_tests",
+        metavar="[NOSE_COVER_TESTS]",
+        default=False,
+        help="Include test modules in coverage report "),
     optparse.Option(
         '--cover-branch', action='store_true',
         help="Measure branch execution. HIGHLY EXPERIMENTAL!"
-- 
cgit v1.2.1


From 72231c6c356253323c4e18d4441401b272997c32 Mon Sep 17 00:00:00 2001
From: David Stanek <dstanek@dstanek.com>
Date: Sat, 20 Feb 2010 18:36:25 -0500
Subject: fixed busted nose integration

---
 coverage/nose_coverage.py | 7 +++----
 coverage/testplugin.py    | 5 +++--
 2 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'coverage')

diff --git a/coverage/nose_coverage.py b/coverage/nose_coverage.py
index 907e6803..b2bf9b5a 100644
--- a/coverage/nose_coverage.py
+++ b/coverage/nose_coverage.py
@@ -3,7 +3,7 @@ import unittest, os
 from nose.plugins import Plugin
 import sys
 
-from coverage.testplugin import CoverageTestWrapper
+from coverage.testplugin import CoverageTestWrapper, options as coverage_opts
 
 log = logging.getLogger(__name__)
 
@@ -22,8 +22,7 @@ class Coverage(Plugin):
         Add options to command line.
         """
         Plugin.options(self, parser, env)
-        from coverage.runner import options
-        for opt in options:
+        for opt in coverage_opts:
             parser.add_option(opt)
     
     def configure(self, options, config):
@@ -64,5 +63,5 @@ class Coverage(Plugin):
         log.debug("Coverage report")
         stream.write("Processing Coverage...")
         # finish up with coverage
-        self.coverage.finish()
+        self.coverage.finish(stream)
 
diff --git a/coverage/testplugin.py b/coverage/testplugin.py
index 7b8c0f43..4ff598a9 100644
--- a/coverage/testplugin.py
+++ b/coverage/testplugin.py
@@ -49,7 +49,7 @@ class CoverageTestWrapper(object):
         # Run the script.
         self.coverage.start()
         
-    def finish(self):
+    def finish(self, stream=None):
         # end coverage and save the results
         self.coverage.stop()
         self.coverage.save()
@@ -76,7 +76,8 @@ class CoverageTestWrapper(object):
 
         if 'report' in self.options.cover_actions:
             self.coverage.report(
-                show_missing=self.options.cover_show_missing, **report_args)
+                show_missing=self.options.cover_show_missing,
+                file=stream, **report_args)
         if 'annotate' in self.options.cover_actions:
             self.coverage.annotate(
                 directory=self.options.cover_directory, **report_args)
-- 
cgit v1.2.1


From 7ccdc87d3e4ad3a7933c3fc34e37213f36f3229a Mon Sep 17 00:00:00 2001
From: David Stanek <dstanek@dstanek.com>
Date: Sat, 20 Feb 2010 19:36:21 -0500
Subject: moved the nose plugin to a better name

--HG--
rename : coverage/nose_coverage.py => coverage/noseplugin.py
---
 coverage/nose_coverage.py | 67 -----------------------------------------------
 coverage/noseplugin.py    | 67 +++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 67 insertions(+), 67 deletions(-)
 delete mode 100644 coverage/nose_coverage.py
 create mode 100644 coverage/noseplugin.py

(limited to 'coverage')

diff --git a/coverage/nose_coverage.py b/coverage/nose_coverage.py
deleted file mode 100644
index b2bf9b5a..00000000
--- a/coverage/nose_coverage.py
+++ /dev/null
@@ -1,67 +0,0 @@
-import logging
-import unittest, os
-from nose.plugins import Plugin
-import sys
-
-from coverage.testplugin import CoverageTestWrapper, options as coverage_opts
-
-log = logging.getLogger(__name__)
-
-
-class Coverage(Plugin):
-    """
-    Activate a coverage report using Ned Batchelder's coverage module.
-    """
-    
-    name = "coverage_new"
-    score = 1
-    status = {}
-    
-    def options(self, parser, env):
-        """
-        Add options to command line.
-        """
-        Plugin.options(self, parser, env)
-        for opt in coverage_opts:
-            parser.add_option(opt)
-    
-    def configure(self, options, config):
-        """
-        Configure plugin.
-        """
-        try:
-            self.status.pop('active')
-        except KeyError:
-            pass
-        Plugin.configure(self, options, config)
-        if self.enabled:
-            try:
-                import coverage
-            except ImportError:
-                log.error("Coverage not available: "
-                          "unable to import coverage module")
-                self.enabled = False
-                return
-        
-        self.config = config
-        self.status['active'] = True
-        self.options = options
-        
-    def begin(self):
-        """
-        Begin recording coverage information.
-        """
-        log.debug("Coverage begin")
-        # Load the runner and start it up
-        self.coverage = CoverageTestWrapper(self.options)
-        self.coverage.start()
-        
-    def report(self, stream):
-        """
-        Output code coverage report.
-        """
-        log.debug("Coverage report")
-        stream.write("Processing Coverage...")
-        # finish up with coverage
-        self.coverage.finish(stream)
-
diff --git a/coverage/noseplugin.py b/coverage/noseplugin.py
new file mode 100644
index 00000000..b2bf9b5a
--- /dev/null
+++ b/coverage/noseplugin.py
@@ -0,0 +1,67 @@
+import logging
+import unittest, os
+from nose.plugins import Plugin
+import sys
+
+from coverage.testplugin import CoverageTestWrapper, options as coverage_opts
+
+log = logging.getLogger(__name__)
+
+
+class Coverage(Plugin):
+    """
+    Activate a coverage report using Ned Batchelder's coverage module.
+    """
+    
+    name = "coverage_new"
+    score = 1
+    status = {}
+    
+    def options(self, parser, env):
+        """
+        Add options to command line.
+        """
+        Plugin.options(self, parser, env)
+        for opt in coverage_opts:
+            parser.add_option(opt)
+    
+    def configure(self, options, config):
+        """
+        Configure plugin.
+        """
+        try:
+            self.status.pop('active')
+        except KeyError:
+            pass
+        Plugin.configure(self, options, config)
+        if self.enabled:
+            try:
+                import coverage
+            except ImportError:
+                log.error("Coverage not available: "
+                          "unable to import coverage module")
+                self.enabled = False
+                return
+        
+        self.config = config
+        self.status['active'] = True
+        self.options = options
+        
+    def begin(self):
+        """
+        Begin recording coverage information.
+        """
+        log.debug("Coverage begin")
+        # Load the runner and start it up
+        self.coverage = CoverageTestWrapper(self.options)
+        self.coverage.start()
+        
+    def report(self, stream):
+        """
+        Output code coverage report.
+        """
+        log.debug("Coverage report")
+        stream.write("Processing Coverage...")
+        # finish up with coverage
+        self.coverage.finish(stream)
+
-- 
cgit v1.2.1