third_party/typ/tools/cov.py

   1 #!/usr/bin/python
   2 # Copyright 2014 Google Inc. All rights reserved.
   3 #
   4 # Licensed under the Apache License, Version 2.0 (the "License");
   5 # you may not use this file except in compliance with the License.
   6 # You may obtain a copy of the License at
   7 #
   8 #    http://www.apache.org/licenses/LICENSE-2.0
   9 #
  10 # Unless required by applicable law or agreed to in writing, software
  11 # distributed under the License is distributed on an "AS IS" BASIS,
  12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 # See the License for the specific language governing permissions and
  14 # limitations under the License.
  15
  16 from __future__ import print_function
  17
  18 import argparse
  19 import sys
  20 import textwrap
  21
  22 is_python3 = bool(sys.version_info.major == 3)
  23
  24
  25 ALL_PRAGMAS = ['no cover', 'no win32', 'python2', 'python3', 'untested',
  26                'win32']
  27 DEFAULT_PRAGMAS = ALL_PRAGMAS[:]
  28
  29 if is_python3:
  30     DEFAULT_PRAGMAS.remove('python3')
  31 else:
  32     DEFAULT_PRAGMAS.remove('python2')
  33
  34 if sys.platform == 'win32':
  35     DEFAULT_PRAGMAS.remove('win32')
  36 else:
  37     DEFAULT_PRAGMAS.remove('no win32')
  38
  39
  40 def add_arguments(parser):
  41     parser.add_argument('--no-pragmas', action='store_true', default=False,
  42                         help='Show all uncovered lines (no pragmas).')
  43     parser.add_argument('--path', action='append', default=[],
  44                         help='Prepend given directories to sys.path.')
  45     parser.add_argument('--pragma', action='append', default=[],
  46                         help=('The coverage pragmas to honor '
  47                               '(defaults to %s).' % DEFAULT_PRAGMAS))
  48     parser.add_argument('--show', action='append', default=[],
  49                         help='Show code protected by the specified pragmas '
  50                              '(uses all pragmas *except* for the ones '
  51                              'specified).')
  52     parser.add_argument('--show-missing', action='store_true',
  53                         default=False, help='Show missing lines.')
  54     parser.add_argument('--source', action='append', default=[],
  55                         help='Limit coverage data to the given directories.')
  56
  57     parser.formatter_class = argparse.RawTextHelpFormatter
  58     parser.epilog = textwrap.dedent("""
  59     Valid pragma values are:
  60         'no cover': The default coverage pragma, this now means we
  61                     truly cannot cover it.
  62         'no win32': Code that only executes when not on Windows.
  63         'python2':  Code that only executes under Python2.
  64         'python3':  Code that only executees under Python3.
  65         'untested': Code that does not yet have tests.
  66         'win32':    Code that only executes on Windows.
  67
  68     In typ, we aim for 'no cover' to only apply to code that executes only
  69     when coverage is not available (and hence can never be counted). Most
  70     code, if annotated at all, should be 'untested', and we should strive
  71     for 'untested' to not be used, either.
  72     """)
  73
  74
  75 def argv_from_args(args):
  76     argv = []
  77     if args.no_pragmas:
  78         argv.append('--no-pragmas')
  79     for arg in args.path:
  80         argv.extend(['--path', arg])
  81     for arg in args.show:
  82         argv.extend(['--show', arg])
  83     if args.show_missing:
  84         argv.append('--show-missing')
  85     for arg in args.source:
  86         argv.extend(['--source', arg])
  87     for arg in args.pragma:
  88         argv.extend(['--pragma', arg])
  89     return argv
  90
  91
  92 def main(argv=None):
  93     parser = argparse.ArgumentParser()
  94     add_arguments(parser)
  95     args, remaining_args = parser.parse_known_args(argv)
  96
  97     for path in args.path:
  98         if path not in sys.path:
  99             sys.path.append(path)
 100
 101     try:
 102         import coverage
 103         from coverage.execfile import run_python_module, run_python_file
 104     except ImportError:
 105         print("Error: coverage is not available.")
 106         sys.exit(1)
 107
 108     cov = coverage.coverage(source=args.source)
 109     cov.erase()
 110     cov.clear_exclude()
 111
 112     if args.no_pragmas:
 113         args.pragma = []
 114
 115     args.pragma = args.pragma or DEFAULT_PRAGMAS
 116
 117     if args.show:
 118         args.show_missing = True
 119     for pragma in args.show:
 120         if pragma in args.pragma:
 121             args.pragma.remove(pragma)
 122
 123     for pragma in args.pragma:
 124         cov.exclude('pragma: %s' % pragma)
 125
 126     ret = 0
 127     cov.start()
 128     try:
 129         if remaining_args[0] == '-m':
 130             run_python_module(remaining_args[1], remaining_args[1:])
 131         else:
 132             run_python_file(remaining_args[0], remaining_args)
 133     except SystemExit as e:
 134         ret = e.code
 135     cov.stop()
 136     cov.save()
 137     cov.report(show_missing=args.show_missing)
 138     return ret
 139
 140
 141 if __name__ == '__main__':
 142     sys.exit(main())