eric: comparison DebugClients/Python/coverage/cmdline.py

-:bedab77d0fa3
+:d6c795b5ce33
 # Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
 # For details: https://bitbucket.org/ned/coveragepy/src/default/NOTICE.txt
 """Command-line support for coverage.py."""
+from __future__ import print_function
 import glob
 import optparse
 import os.path
 import sys
 import textwrap
 import traceback
 from coverage import env
 from coverage.collector import CTracer
+from coverage.debug import info_formatter, info_header
 from coverage.execfile import run_python_file, run_python_module
-from coverage.misc import CoverageException, ExceptionDuringRun, NoSource
+from coverage.misc import BaseCoverageException, ExceptionDuringRun, NoSource
-from coverage.debug import info_formatter, info_header
+from coverage.results import should_fail_under
 class Opts(object):
 """A namespace class for individual options we'll build parsers from."""
 append = optparse.make_option(
 '-a', '--append', action='store_true',
-help="Append coverage data to .coverage, otherwise it is started clean with each run.",
+help="Append coverage data to .coverage, otherwise it starts clean each time.",
 )
 branch = optparse.make_option(
 '', '--branch', action='store_true',
 help="Measure branch coverage in addition to statement coverage.",
 )
 directory = optparse.make_option(
 '-d', '--directory', action='store', metavar="DIR",
 help="Write the output files to DIR.",
 )
 fail_under = optparse.make_option(
-'', '--fail-under', action='store', metavar="MIN", type="int",
+'', '--fail-under', action='store', metavar="MIN", type="float",
 help="Exit with a status of 2 if the total coverage is less than MIN.",
 )
 help = optparse.make_option(
 '-h', '--help', action='store_true',
 help="Get help on this command.",
 class CmdOptionParser(CoverageOptionParser):
 """Parse one of the new-style commands for coverage.py."""
-def __init__(self, action, options=None, defaults=None, usage=None, description=None):
+def __init__(self, action, options, defaults=None, usage=None, description=None):
 """Create an OptionParser for a coverage.py command.
 `action` is the slug to put into `options.action`.
 `options` is a list of Option's for the command.
 `defaults` is a dict of default value for options.
 super(CmdOptionParser, self).__init__(
 usage=usage,
 description=description,
 )
 self.set_defaults(action=action, **(defaults or {}))
-if options:
+self.add_options(options)
-self.add_options(options)
 self.cmd = action
 def __eq__(self, other):
 # A convenience equality, so that I can put strings in unit test
 # results, and they will compare equal to objects.
 return (other == "<CmdOptionParser:%s>" % self.cmd)
+__hash__ = None     # This object doesn't need to be hashed.
 def get_prog_name(self):
 """Override of an undocumented function in optparse.OptionParser."""
 program_name = super(CmdOptionParser, self).get_prog_name()
 # Include the sub-command for this parser as part of the command.
-return "%(command)s %(subcommand)s" % {'command': program_name, 'subcommand': self.cmd}
+return "{command} {subcommand}".format(command=program_name, subcommand=self.cmd)
 GLOBAL_ARGS = [
 Opts.debug,
 Opts.help,
 ),
 ),
 'combine': CmdOptionParser(
 "combine",
-GLOBAL_ARGS,
+[
-usage="<path1> <path2> ... <pathN>",
+Opts.append,
+] + GLOBAL_ARGS,
+usage="[options] <path1> <path2> ... <pathN>",
 description=(
 "Combine data from multiple coverage files collected "
 "with 'run -p'.  The combined results are written to a single "
 "file representing the union of the data. The positional "
 "arguments are data files or directories containing data files. "
 ),
 ),
 'erase': CmdOptionParser(
 "erase", GLOBAL_ARGS,
-usage=" ",
 description="Erase previously collected coverage data.",
 ),
 'help': CmdOptionParser(
 "help", GLOBAL_ARGS,
 Opts.fail_under,
 Opts.ignore_errors,
 Opts.include,
 Opts.omit,
 Opts.title,
+Opts.skip_covered,
 ] + GLOBAL_ARGS,
 usage="[options] [modules]",
 description=(
 "Create an HTML report of the coverage of the files.  "
 "Each file gets its own page, with the source decorated to show "
 self.path_exists = _path_exists or os.path.exists
 self.global_option = False
 self.coverage = None
-self.program_name = os.path.basename(sys.argv[0])
+program_path = sys.argv[0]
+if program_path.endswith(os.path.sep + '__main__.py'):
+# The path is the main module of a package; get that path instead.
+program_path = os.path.dirname(program_path)
+self.program_name = os.path.basename(program_path)
 if env.WINDOWS:
 # entry_points={'console_scripts':...} on Windows makes files
 # called coverage.exe, coverage3.exe, and coverage-3.5.exe. These
 # invoke coverage-script.py, coverage3-script.py, and
 # coverage-3.5-script.py.  argv[0] is the .py file, but we want to
 # Handle help and version.
 if self.do_help(options, args, parser):
 return OK
-# Check for conflicts and problems in the options.
-if not self.args_ok(options, args):
-return ERR
 # We need to be able to import from the current directory, because
 # plugins may try to, for example, to read Django settings.
 sys.path[0] = ''
 # Listify the list options.
 omit = unshell_list(options.omit)
 include = unshell_list(options.include)
 debug = unshell_list(options.debug)
 # Do something.
-self.coverage = self.covpkg.coverage(
+self.coverage = self.covpkg.Coverage(
 data_suffix=options.parallel_mode,
 cover_pylib=options.pylib,
 timid=options.timid,
 branch=options.branch,
 config_file=options.rcfile,
 elif options.action == "run":
 return self.do_run(options, args)
 elif options.action == "combine":
-self.coverage.load()
+if options.append:
+self.coverage.load()
 data_dirs = args or None
-self.coverage.combine(data_dirs)
+self.coverage.combine(data_dirs, strict=True)
 self.coverage.save()
 return OK
 # Remaining actions are reporting, with some common options.
 report_args = dict(
 self.coverage.annotate(
 directory=options.directory, **report_args)
 elif options.action == "html":
 total = self.coverage.html_report(
 directory=options.directory, title=options.title,
-**report_args)
+skip_covered=options.skip_covered, **report_args)
 elif options.action == "xml":
 outfile = options.outfile
 total = self.coverage.xml_report(outfile=outfile, **report_args)
 if total is not None:
 # Apply the command line fail-under options, and then use the config
 # value, so we can get fail_under from the config file.
 if options.fail_under is not None:
 self.coverage.set_option("report:fail_under", options.fail_under)
-if self.coverage.get_option("report:fail_under"):
+fail_under = self.coverage.get_option("report:fail_under")
+precision = self.coverage.get_option("report:precision")
-# Total needs to be rounded, but be careful of 0 and 100.
+if should_fail_under(total, fail_under, precision):
-if 0 < total < 1:
+return FAIL_UNDER
-total = 1
-elif 99 < total < 100:
-total = 99
-else:
-total = round(total)
-if total >= self.coverage.get_option("report:fail_under"):
-return OK
-else:
-return FAIL_UNDER
 return OK
 def help(self, error=None, topic=None, parser=None):
 """Display an error message, or the named topic."""
 assert error or topic or parser
 if error:
-print(error)
+print(error, file=sys.stderr)
-print("Use '%s help' for help." % (self.program_name,))
+print("Use '%s help' for help." % (self.program_name,), file=sys.stderr)
 elif parser:
 print(parser.format_help().strip())
 else:
 help_params = dict(self.covpkg.__dict__)
 help_params['program_name'] = self.program_name
 self.help_fn(topic='version')
 return True
 return False
-def args_ok(self, options, args):
-"""Check for conflicts and problems in the options.
-Returns True if everything is OK, or False if not.
-"""
-if options.action == "run" and not args:
-self.help_fn("Nothing to do.")
-return False
-return True
 def do_run(self, options, args):
 """Implementation of 'coverage run'."""
+if not args:
+self.help_fn("Nothing to do.")
+return ERR
 if options.append and self.coverage.get_option("run:parallel"):
 self.help_fn("Can't append to data files in parallel mode.")
 return ERR
+if options.concurrency == "multiprocessing":
+# Can't set other run-affecting command line options with
+# multiprocessing.
+for opt_name in ['branch', 'include', 'omit', 'pylib', 'source', 'timid']:
+# As it happens, all of these options have no default, meaning
+# they will be None if they have not been specified.
+if getattr(options, opt_name) is not None:
+self.help_fn(
+"Options affecting multiprocessing must be specified "
+"in a configuration file."
+)
+return ERR
 if not self.coverage.get_option("run:parallel"):
 if not options.append:
 self.coverage.erase()
 def do_debug(self, args):
 """Implementation of 'coverage debug'."""
 if not args:
-self.help_fn("What information would you like: data, sys?")
+self.help_fn("What information would you like: config, data, sys?")
 return ERR
 for info in args:
 if info == 'sys':
 sys_info = self.coverage.sys_info()
 if plugin:
 line += " [%s]" % plugin
 print(line)
 else:
 print("No data collected")
+elif info == 'config':
+print(info_header("config"))
+config_info = self.coverage.config.__dict__.items()
+for line in info_formatter(config_info):
+print(" %s" % line)
 else:
 self.help_fn("Don't know what you mean by %r" % info)
 return ERR
 return OK
 status = CoverageScript().command_line(argv)
 except ExceptionDuringRun as err:
 # An exception was caught while running the product code.  The
 # sys.exc_info() return tuple is packed into an ExceptionDuringRun
 # exception.
-traceback.print_exception(*err.args)
+traceback.print_exception(*err.args)    # pylint: disable=no-value-for-parameter
 status = ERR
-except CoverageException as err:
+except BaseCoverageException as err:
 # A controlled error inside coverage.py: print the message to the user.
 print(err)
 status = ERR
 except SystemExit as err:
 # The user called `sys.exit()`.  Exit with their argument, if any.

Mercurial Repositories > eric / file comparison

comparison: DebugClients/Python/coverage/cmdline.py

DebugClients/Python/coverage/cmdline.py