Add python coverage 3.7 to depot tools.

third_party/coverage/cmdline.py

Index: third_party/coverage/cmdline.py
diff --git a/third_party/coverage/cmdline.py b/third_party/coverage/cmdline.py
new file mode 100644
index 0000000000000000000000000000000000000000..0881313e2dbba9803b66d6c34222b8e9466c0fb7
--- /dev/null
+++ b/third_party/coverage/cmdline.py
@@ -0,0 +1,740 @@
+"""Command-line support for Coverage."""
+
+import optparse, os, sys, traceback
+
+from coverage.backward import sorted                # pylint: disable=W0622
+from coverage.execfile import run_python_file, run_python_module
+from coverage.misc import CoverageException, ExceptionDuringRun, NoSource
+from coverage.debug import info_formatter
+
+
+class Opts(object):
+    """A namespace class for individual options we'll build parsers from."""
+
+    append = optparse.make_option(
+        '-a', '--append', action='store_false', dest="erase_first",
+        help="Append coverage data to .coverage, otherwise it is started "
+                "clean with each run."
+        )
+    branch = optparse.make_option(
+        '', '--branch', action='store_true',
+        help="Measure branch coverage in addition to statement coverage."
+        )
+    debug = optparse.make_option(
+        '', '--debug', action='store', metavar="OPTS",
+        help="Debug options, separated by commas"
+        )
+    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",
+        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."
+        )
+    ignore_errors = optparse.make_option(
+        '-i', '--ignore-errors', action='store_true',
+        help="Ignore errors while reading source files."
+        )
+    include = optparse.make_option(
+        '', '--include', action='store',
+        metavar="PAT1,PAT2,...",
+        help="Include files only when their filename path matches one of "
+                "these patterns.  Usually needs quoting on the command line."
+        )
+    pylib = optparse.make_option(
+        '-L', '--pylib', action='store_true',
+        help="Measure coverage even inside the Python installed library, "
+                "which isn't done by default."
+        )
+    show_missing = optparse.make_option(
+        '-m', '--show-missing', action='store_true',
+        help="Show line numbers of statements in each module that weren't "
+                "executed."
+        )
+    old_omit = optparse.make_option(
+        '-o', '--omit', action='store',
+        metavar="PAT1,PAT2,...",
+        help="Omit files when their filename matches one of these patterns. "
+                "Usually needs quoting on the command line."
+        )
+    omit = optparse.make_option(
+        '', '--omit', action='store',
+        metavar="PAT1,PAT2,...",
+        help="Omit files when their filename matches one of these patterns. "
+                "Usually needs quoting on the command line."
+        )
+    output_xml = optparse.make_option(
+        '-o', '', action='store', dest="outfile",
+        metavar="OUTFILE",
+        help="Write the XML report to this file. Defaults to 'coverage.xml'"
+        )
+    parallel_mode = optparse.make_option(
+        '-p', '--parallel-mode', action='store_true',
+        help="Append the machine name, process id and random number to the "
+                ".coverage data file name to simplify collecting data from "
+                "many processes."
+        )
+    module = optparse.make_option(
+        '-m', '--module', action='store_true',
+        help="<pyfile> is an importable Python module, not a script path, "
+                "to be run as 'python -m' would run it."
+        )
+    rcfile = optparse.make_option(
+        '', '--rcfile', action='store',
+        help="Specify configuration file.  Defaults to '.coveragerc'"
+        )
+    source = optparse.make_option(
+        '', '--source', action='store', metavar="SRC1,SRC2,...",
+        help="A list of packages or directories of code to be measured."
+        )
+    timid = optparse.make_option(
+        '', '--timid', action='store_true',
+        help="Use a simpler but slower trace method.  Try this if you get "
+                "seemingly impossible results!"
+        )
+    title = optparse.make_option(
+        '', '--title', action='store', metavar="TITLE",
+        help="A text string to use as the title on the HTML."
+        )
+    version = optparse.make_option(
+        '', '--version', action='store_true',
+        help="Display version information and exit."
+        )
+
+
+class CoverageOptionParser(optparse.OptionParser, object):
+    """Base OptionParser for coverage.
+
+    Problems don't exit the program.
+    Defaults are initialized for all options.
+
+    """
+
+    def __init__(self, *args, **kwargs):
+        super(CoverageOptionParser, self).__init__(
+            add_help_option=False, *args, **kwargs
+            )
+        self.set_defaults(
+            actions=[],
+            branch=None,
+            debug=None,
+            directory=None,
+            fail_under=None,
+            help=None,
+            ignore_errors=None,
+            include=None,
+            omit=None,
+            parallel_mode=None,
+            module=None,
+            pylib=None,
+            rcfile=True,
+            show_missing=None,
+            source=None,
+            timid=None,
+            title=None,
+            erase_first=None,
+            version=None,
+            )
+
+        self.disable_interspersed_args()
+        self.help_fn = self.help_noop
+
+    def help_noop(self, error=None, topic=None, parser=None):
+        """No-op help function."""
+        pass
+
+    class OptionParserError(Exception):
+        """Used to stop the optparse error handler ending the process."""
+        pass
+
+    def parse_args(self, args=None, options=None):
+        """Call optparse.parse_args, but return a triple:
+
+        (ok, options, args)
+
+        """
+        try:
+            options, args = \
+                super(CoverageOptionParser, self).parse_args(args, options)
+        except self.OptionParserError:
+            return False, None, None
+        return True, options, args
+
+    def error(self, msg):
+        """Override optparse.error so sys.exit doesn't get called."""
+        self.help_fn(msg)
+        raise self.OptionParserError
+
+
+class ClassicOptionParser(CoverageOptionParser):
+    """Command-line parser for coverage.py classic arguments."""
+
+    def __init__(self):
+        super(ClassicOptionParser, self).__init__()
+
+        self.add_action('-a', '--annotate', 'annotate')
+        self.add_action('-b', '--html', 'html')
+        self.add_action('-c', '--combine', 'combine')
+        self.add_action('-e', '--erase', 'erase')
+        self.add_action('-r', '--report', 'report')
+        self.add_action('-x', '--execute', 'execute')
+
+        self.add_options([
+            Opts.directory,
+            Opts.help,
+            Opts.ignore_errors,
+            Opts.pylib,
+            Opts.show_missing,
+            Opts.old_omit,
+            Opts.parallel_mode,
+            Opts.timid,
+            Opts.version,
+        ])
+
+    def add_action(self, dash, dashdash, action_code):
+        """Add a specialized option that is the action to execute."""
+        option = self.add_option(dash, dashdash, action='callback',
+            callback=self._append_action
+            )
+        option.action_code = action_code
+
+    def _append_action(self, option, opt_unused, value_unused, parser):
+        """Callback for an option that adds to the `actions` list."""
+        parser.values.actions.append(option.action_code)
+
+
+class CmdOptionParser(CoverageOptionParser):
+    """Parse one of the new-style commands for coverage.py."""
+
+    def __init__(self, action, options=None, defaults=None, usage=None,
+                cmd=None, description=None
+                ):
+        """Create an OptionParser for a coverage command.
+
+        `action` is the slug to put into `options.actions`.
+        `options` is a list of Option's for the command.
+        `defaults` is a dict of default value for options.
+        `usage` is the usage string to display in help.
+        `cmd` is the command name, if different than `action`.
+        `description` is the description of the command, for the help text.
+
+        """
+        if usage:
+            usage = "%prog " + usage
+        super(CmdOptionParser, self).__init__(
+            prog="coverage %s" % (cmd or action),
+            usage=usage,
+            description=description,
+        )
+        self.set_defaults(actions=[action], **(defaults or {}))
+        if options:
+            self.add_options(options)
+        self.cmd = cmd or 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)
+
+GLOBAL_ARGS = [
+    Opts.rcfile,
+    Opts.help,
+    ]
+
+CMDS = {
+    'annotate': CmdOptionParser("annotate",
+        [
+            Opts.directory,
+            Opts.ignore_errors,
+            Opts.omit,
+            Opts.include,
+            ] + GLOBAL_ARGS,
+        usage = "[options] [modules]",
+        description = "Make annotated copies of the given files, marking "
+            "statements that are executed with > and statements that are "
+            "missed with !."
+        ),
+
+    'combine': CmdOptionParser("combine", GLOBAL_ARGS,
+        usage = " ",
+        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."
+        ),
+
+    'debug': CmdOptionParser("debug", GLOBAL_ARGS,
+        usage = "<topic>",
+        description = "Display information on the internals of coverage.py, "
+            "for diagnosing problems. "
+            "Topics are 'data' to show a summary of the collected data, "
+            "or 'sys' to show installation information."
+        ),
+
+    'erase': CmdOptionParser("erase", GLOBAL_ARGS,
+        usage = " ",
+        description = "Erase previously collected coverage data."
+        ),
+
+    'help': CmdOptionParser("help", GLOBAL_ARGS,
+        usage = "[command]",
+        description = "Describe how to use coverage.py"
+        ),
+
+    'html': CmdOptionParser("html",
+        [
+            Opts.directory,
+            Opts.fail_under,
+            Opts.ignore_errors,
+            Opts.omit,
+            Opts.include,
+            Opts.title,
+            ] + 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 "
+            "executed, excluded, and missed lines."
+        ),
+
+    'report': CmdOptionParser("report",
+        [
+            Opts.fail_under,
+            Opts.ignore_errors,
+            Opts.omit,
+            Opts.include,
+            Opts.show_missing,
+            ] + GLOBAL_ARGS,
+        usage = "[options] [modules]",
+        description = "Report coverage statistics on modules."
+        ),
+
+    'run': CmdOptionParser("execute",
+        [
+            Opts.append,
+            Opts.branch,
+            Opts.debug,
+            Opts.pylib,
+            Opts.parallel_mode,
+            Opts.module,
+            Opts.timid,
+            Opts.source,
+            Opts.omit,
+            Opts.include,
+            ] + GLOBAL_ARGS,
+        defaults = {'erase_first': True},
+        cmd = "run",
+        usage = "[options] <pyfile> [program options]",
+        description = "Run a Python program, measuring code execution."
+        ),
+
+    'xml': CmdOptionParser("xml",
+        [
+            Opts.fail_under,
+            Opts.ignore_errors,
+            Opts.omit,
+            Opts.include,
+            Opts.output_xml,
+            ] + GLOBAL_ARGS,
+        cmd = "xml",
+        usage = "[options] [modules]",
+        description = "Generate an XML report of coverage results."
+        ),
+    }
+
+
+OK, ERR, FAIL_UNDER = 0, 1, 2
+
+
+class CoverageScript(object):
+    """The command-line interface to Coverage."""
+
+    def __init__(self, _covpkg=None, _run_python_file=None,
+                 _run_python_module=None, _help_fn=None):
+        # _covpkg is for dependency injection, so we can test this code.
+        if _covpkg:
+            self.covpkg = _covpkg
+        else:
+            import coverage
+            self.covpkg = coverage
+
+        # For dependency injection:
+        self.run_python_file = _run_python_file or run_python_file
+        self.run_python_module = _run_python_module or run_python_module
+        self.help_fn = _help_fn or self.help
+        self.classic = False
+
+        self.coverage = None
+
+    def command_line(self, argv):
+        """The bulk of the command line interface to Coverage.
+
+        `argv` is the argument list to process.
+
+        Returns 0 if all is well, 1 if something went wrong.
+
+        """
+        # Collect the command-line options.
+        if not argv:
+            self.help_fn(topic='minimum_help')
+            return OK
+
+        # The command syntax we parse depends on the first argument.  Classic
+        # syntax always starts with an option.
+        self.classic = argv[0].startswith('-')
+        if self.classic:
+            parser = ClassicOptionParser()
+        else:
+            parser = CMDS.get(argv[0])
+            if not parser:
+                self.help_fn("Unknown command: '%s'" % argv[0])
+                return ERR
+            argv = argv[1:]
+
+        parser.help_fn = self.help_fn
+        ok, options, args = parser.parse_args(argv)
+        if not ok:
+            return ERR
+
+        # 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
+
+        # Listify the list options.
+        source = unshell_list(options.source)
+        omit = unshell_list(options.omit)
+        include = unshell_list(options.include)
+        debug = unshell_list(options.debug)
+
+        # Do something.
+        self.coverage = self.covpkg.coverage(
+            data_suffix = options.parallel_mode,
+            cover_pylib = options.pylib,
+            timid = options.timid,
+            branch = options.branch,
+            config_file = options.rcfile,
+            source = source,
+            omit = omit,
+            include = include,
+            debug = debug,
+            )
+
+        if 'debug' in options.actions:
+            return self.do_debug(args)
+
+        if 'erase' in options.actions or options.erase_first:
+            self.coverage.erase()
+        else:
+            self.coverage.load()
+
+        if 'execute' in options.actions:
+            self.do_execute(options, args)
+
+        if 'combine' in options.actions:
+            self.coverage.combine()
+            self.coverage.save()
+
+        # Remaining actions are reporting, with some common options.
+        report_args = dict(
+            morfs = args,
+            ignore_errors = options.ignore_errors,
+            omit = omit,
+            include = include,
+            )
+
+        if 'report' in options.actions:
+            total = self.coverage.report(
+                show_missing=options.show_missing, **report_args)
+        if 'annotate' in options.actions:
+            self.coverage.annotate(
+                directory=options.directory, **report_args)
+        if 'html' in options.actions:
+            total = self.coverage.html_report(
+                directory=options.directory, title=options.title,
+                **report_args)
+        if 'xml' in options.actions:
+            outfile = options.outfile
+            total = self.coverage.xml_report(outfile=outfile, **report_args)
+
+        if options.fail_under is not None:
+            if total >= options.fail_under:
+                return OK
+            else:
+                return FAIL_UNDER
+        else:
+            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("Use 'coverage help' for help.")
+        elif parser:
+            print(parser.format_help().strip())
+        else:
+            help_msg = HELP_TOPICS.get(topic, '').strip()
+            if help_msg:
+                print(help_msg % self.covpkg.__dict__)
+            else:
+                print("Don't know topic %r" % topic)
+
+    def do_help(self, options, args, parser):
+        """Deal with help requests.
+
+        Return True if it handled the request, False if not.
+
+        """
+        # Handle help.
+        if options.help:
+            if self.classic:
+                self.help_fn(topic='help')
+            else:
+                self.help_fn(parser=parser)
+            return True
+
+        if "help" in options.actions:
+            if args:
+                for a in args:
+                    parser = CMDS.get(a)
+                    if parser:
+                        self.help_fn(parser=parser)
+                    else:
+                        self.help_fn(topic=a)
+            else:
+                self.help_fn(topic='help')
+            return True
+
+        # Handle version.
+        if options.version:
+            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.
+
+        """
+        for i in ['erase', 'execute']:
+            for j in ['annotate', 'html', 'report', 'combine']:
+                if (i in options.actions) and (j in options.actions):
+                    self.help_fn("You can't specify the '%s' and '%s' "
+                              "options at the same time." % (i, j))
+                    return False
+
+        if not options.actions:
+            self.help_fn(
+                "You must specify at least one of -e, -x, -c, -r, -a, or -b."
+                )
+            return False
+        args_allowed = (
+            'execute' in options.actions or
+            'annotate' in options.actions or
+            'html' in options.actions or
+            'debug' in options.actions or
+            'report' in options.actions or
+            'xml' in options.actions
+            )
+        if not args_allowed and args:
+            self.help_fn("Unexpected arguments: %s" % " ".join(args))
+            return False
+
+        if 'execute' in options.actions and not args:
+            self.help_fn("Nothing to do.")
+            return False
+
+        return True
+
+    def do_execute(self, options, args):
+        """Implementation of 'coverage run'."""
+
+        # Set the first path element properly.
+        old_path0 = sys.path[0]
+
+        # Run the script.
+        self.coverage.start()
+        code_ran = True
+        try:
+            try:
+                if options.module:
+                    sys.path[0] = ''
+                    self.run_python_module(args[0], args)
+                else:
+                    filename = args[0]
+                    sys.path[0] = os.path.abspath(os.path.dirname(filename))
+                    self.run_python_file(filename, args)
+            except NoSource:
+                code_ran = False
+                raise
+        finally:
+            self.coverage.stop()
+            if code_ran:
+                self.coverage.save()
+
+            # Restore the old path
+            sys.path[0] = old_path0
+
+    def do_debug(self, args):
+        """Implementation of 'coverage debug'."""
+
+        if not args:
+            self.help_fn("What information would you like: data, sys?")
+            return ERR
+        for info in args:
+            if info == 'sys':
+                print("-- sys ----------------------------------------")
+                for line in info_formatter(self.coverage.sysinfo()):
+                    print(" %s" % line)
+            elif info == 'data':
+                print("-- data ---------------------------------------")
+                self.coverage.load()
+                print("path: %s" % self.coverage.data.filename)
+                print("has_arcs: %r" % self.coverage.data.has_arcs())
+                summary = self.coverage.data.summary(fullpath=True)
+                if summary:
+                    filenames = sorted(summary.keys())
+                    print("\n%d files:" % len(filenames))
+                    for f in filenames:
+                        print("%s: %d lines" % (f, summary[f]))
+                else:
+                    print("No data collected")
+            else:
+                self.help_fn("Don't know what you mean by %r" % info)
+                return ERR
+        return OK
+
+
+def unshell_list(s):
+    """Turn a command-line argument into a list."""
+    if not s:
+        return None
+    if sys.platform == 'win32':
+        # When running coverage as coverage.exe, some of the behavior
+        # of the shell is emulated: wildcards are expanded into a list of
+        # filenames.  So you have to single-quote patterns on the command
+        # line, but (not) helpfully, the single quotes are included in the
+        # argument, so we have to strip them off here.
+        s = s.strip("'")
+    return s.split(',')
+
+
+HELP_TOPICS = {
+# -------------------------
+'classic':
+r"""Coverage.py version %(__version__)s
+Measure, collect, and report on code coverage in Python programs.
+
+Usage:
+
+coverage -x [-p] [-L] [--timid] MODULE.py [ARG1 ARG2 ...]
+    Execute the module, passing the given command-line arguments, collecting
+    coverage data.  With the -p option, include the machine name and process
+    id in the .coverage file name.  With -L, measure coverage even inside the
+    Python installed library, which isn't done by default.  With --timid, use a
+    simpler but slower trace method.
+
+coverage -e
+    Erase collected coverage data.
+
+coverage -c
+    Combine data from multiple coverage files (as created by -p option above)
+    and store it into a single file representing the union of the coverage.
+
+coverage -r [-m] [-i] [-o DIR,...] [FILE1 FILE2 ...]
+    Report on the statement coverage for the given files.  With the -m
+    option, show line numbers of the statements that weren't executed.
+
+coverage -b -d DIR [-i] [-o DIR,...] [FILE1 FILE2 ...]
+    Create an HTML report of the coverage of the given files.  Each file gets
+    its own page, with the file listing decorated to show executed, excluded,
+    and missed lines.
+
+coverage -a [-d DIR] [-i] [-o DIR,...] [FILE1 FILE2 ...]
+    Make annotated copies of the given files, marking statements that
+    are executed with > and statements that are missed with !.
+
+-d DIR
+    Write output files for -b or -a to this directory.
+
+-i  Ignore errors while reporting or annotating.
+
+-o DIR,...
+    Omit reporting or annotating files when their filename path starts with
+    a directory listed in the omit list.
+    e.g. coverage -i -r -o c:\python25,lib\enthought\traits
+
+Coverage data is saved in the file .coverage by default.  Set the
+COVERAGE_FILE environment variable to save it somewhere else.
+""",
+# -------------------------
+'help': """\
+Coverage.py, version %(__version__)s
+Measure, collect, and report on code coverage in Python programs.
+
+usage: coverage <command> [options] [args]
+
+Commands:
+    annotate    Annotate source files with execution information.
+    combine     Combine a number of data files.
+    erase       Erase previously collected coverage data.
+    help        Get help on using coverage.py.
+    html        Create an HTML report.
+    report      Report coverage stats on modules.
+    run         Run a Python program and measure code execution.
+    xml         Create an XML report of coverage results.
+
+Use "coverage help <command>" for detailed help on any command.
+Use "coverage help classic" for help on older command syntax.
+For more information, see %(__url__)s
+""",
+# -------------------------
+'minimum_help': """\
+Code coverage for Python.  Use 'coverage help' for help.
+""",
+# -------------------------
+'version': """\
+Coverage.py, version %(__version__)s.  %(__url__)s
+""",
+}
+
+
+def main(argv=None):
+    """The main entry point to Coverage.
+
+    This is installed as the script entry point.
+
+    """
+    if argv is None:
+        argv = sys.argv[1:]
+    try:
+        status = CoverageScript().command_line(argv)
+    except ExceptionDuringRun:
+        # An exception was caught while running the product code.  The
+        # sys.exc_info() return tuple is packed into an ExceptionDuringRun
+        # exception.
+        _, err, _ = sys.exc_info()
+        traceback.print_exception(*err.args)
+        status = ERR
+    except CoverageException:
+        # A controlled error inside coverage.py: print the message to the user.
+        _, err, _ = sys.exc_info()
+        print(err)
+        status = ERR
+    except SystemExit:
+        # The user called `sys.exit()`.  Exit with their argument, if any.
+        _, err, _ = sys.exc_info()
+        if err.args:
+            status = err.args[0]
+        else:
+            status = None
+    return status