| OLD | NEW |
|---|
| (Empty) |
| 1 """Execute files of Python code.""" | |
| 2 | |
| 3 import imp, os, sys | |
| 4 | |
| 5 from coverage.backward import exec_code_object, open_source | |
| 6 from coverage.misc import NoSource, ExceptionDuringRun | |
| 7 | |
| 8 | |
| 9 try: | |
| 10 # In Py 2.x, the builtins were in __builtin__ | |
| 11 BUILTINS = sys.modules['__builtin__'] | |
| 12 except KeyError: | |
| 13 # In Py 3.x, they're in builtins | |
| 14 BUILTINS = sys.modules['builtins'] | |
| 15 | |
| 16 | |
| 17 def rsplit1(s, sep): | |
| 18 """The same as s.rsplit(sep, 1), but works in 2.3""" | |
| 19 parts = s.split(sep) | |
| 20 return sep.join(parts[:-1]), parts[-1] | |
| 21 | |
| 22 | |
| 23 def run_python_module(modulename, args): | |
| 24 """Run a python module, as though with ``python -m name args...``. | |
| 25 | |
| 26 `modulename` is the name of the module, possibly a dot-separated name. | |
| 27 `args` is the argument array to present as sys.argv, including the first | |
| 28 element naming the module being executed. | |
| 29 | |
| 30 """ | |
| 31 openfile = None | |
| 32 glo, loc = globals(), locals() | |
| 33 try: | |
| 34 try: | |
| 35 # Search for the module - inside its parent package, if any - using | |
| 36 # standard import mechanics. | |
| 37 if '.' in modulename: | |
| 38 packagename, name = rsplit1(modulename, '.') | |
| 39 package = __import__(packagename, glo, loc, ['__path__']) | |
| 40 searchpath = package.__path__ | |
| 41 else: | |
| 42 packagename, name = None, modulename | |
| 43 searchpath = None # "top-level search" in imp.find_module() | |
| 44 openfile, pathname, _ = imp.find_module(name, searchpath) | |
| 45 | |
| 46 # Complain if this is a magic non-file module. | |
| 47 if openfile is None and pathname is None: | |
| 48 raise NoSource( | |
| 49 "module does not live in a file: %r" % modulename | |
| 50 ) | |
| 51 | |
| 52 # If `modulename` is actually a package, not a mere module, then we | |
| 53 # pretend to be Python 2.7 and try running its __main__.py script. | |
| 54 if openfile is None: | |
| 55 packagename = modulename | |
| 56 name = '__main__' | |
| 57 package = __import__(packagename, glo, loc, ['__path__']) | |
| 58 searchpath = package.__path__ | |
| 59 openfile, pathname, _ = imp.find_module(name, searchpath) | |
| 60 except ImportError: | |
| 61 _, err, _ = sys.exc_info() | |
| 62 raise NoSource(str(err)) | |
| 63 finally: | |
| 64 if openfile: | |
| 65 openfile.close() | |
| 66 | |
| 67 # Finally, hand the file off to run_python_file for execution. | |
| 68 args[0] = pathname | |
| 69 run_python_file(pathname, args, package=packagename) | |
| 70 | |
| 71 | |
| 72 def run_python_file(filename, args, package=None): | |
| 73 """Run a python file as if it were the main program on the command line. | |
| 74 | |
| 75 `filename` is the path to the file to execute, it need not be a .py file. | |
| 76 `args` is the argument array to present as sys.argv, including the first | |
| 77 element naming the file being executed. `package` is the name of the | |
| 78 enclosing package, if any. | |
| 79 | |
| 80 """ | |
| 81 # Create a module to serve as __main__ | |
| 82 old_main_mod = sys.modules['__main__'] | |
| 83 main_mod = imp.new_module('__main__') | |
| 84 sys.modules['__main__'] = main_mod | |
| 85 main_mod.__file__ = filename | |
| 86 if package: | |
| 87 main_mod.__package__ = package | |
| 88 main_mod.__builtins__ = BUILTINS | |
| 89 | |
| 90 # Set sys.argv and the first path element properly. | |
| 91 old_argv = sys.argv | |
| 92 old_path0 = sys.path[0] | |
| 93 sys.argv = args | |
| 94 if package: | |
| 95 sys.path[0] = '' | |
| 96 else: | |
| 97 sys.path[0] = os.path.abspath(os.path.dirname(filename)) | |
| 98 | |
| 99 try: | |
| 100 # Open the source file. | |
| 101 try: | |
| 102 source_file = open_source(filename) | |
| 103 except IOError: | |
| 104 raise NoSource("No file to run: %r" % filename) | |
| 105 | |
| 106 try: | |
| 107 source = source_file.read() | |
| 108 finally: | |
| 109 source_file.close() | |
| 110 | |
| 111 # We have the source. `compile` still needs the last line to be clean, | |
| 112 # so make sure it is, then compile a code object from it. | |
| 113 if not source or source[-1] != '\n': | |
| 114 source += '\n' | |
| 115 code = compile(source, filename, "exec") | |
| 116 | |
| 117 # Execute the source file. | |
| 118 try: | |
| 119 exec_code_object(code, main_mod.__dict__) | |
| 120 except SystemExit: | |
| 121 # The user called sys.exit(). Just pass it along to the upper | |
| 122 # layers, where it will be handled. | |
| 123 raise | |
| 124 except: | |
| 125 # Something went wrong while executing the user code. | |
| 126 # Get the exc_info, and pack them into an exception that we can | |
| 127 # throw up to the outer loop. We peel two layers off the traceback | |
| 128 # so that the coverage.py code doesn't appear in the final printed | |
| 129 # traceback. | |
| 130 typ, err, tb = sys.exc_info() | |
| 131 raise ExceptionDuringRun(typ, err, tb.tb_next.tb_next) | |
| 132 finally: | |
| 133 # Restore the old __main__ | |
| 134 sys.modules['__main__'] = old_main_mod | |
| 135 | |
| 136 # Restore the old argv and path | |
| 137 sys.argv = old_argv | |
| 138 sys.path[0] = old_path0 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 225633007:
Upgrade to coverage 3.7.1 and have it auto-build itself on first use. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/tools/build