Implement XML-based reports

Author: o11c

.gitignore

@@ -6,3 +6,4 @@ __pycache__
 /build
 /env
 docs/build/
+/out/

lib-typing/3.2/typing.py

@@ -51,6 +51,8 @@
     # Structural checks, a.k.a. protocols.
     'Reversible',
     'SupportsAbs',
+    'SupportsBytes',
+    'SupportsComplex',
     'SupportsFloat',
     'SupportsInt',
     'SupportsRound',

mypy/build.py

@@ -151,7 +151,13 @@ def build(program_path: str,
     if alt_lib_path:
         lib_path.insert(0, alt_lib_path)
 
-    reports = Reports(data_dir, report_dirs)
+    if program_text is None:
+        program_path = program_path or lookup_program(module, lib_path)
+        program_text = read_program(program_path)
+    else:
+        program_path = program_path or '<string>'
+
+    reports = Reports(program_path, data_dir, report_dirs)
 
     # Construct a build manager object that performs all the stages of the
     # build in the correct order.
@@ -163,12 +169,6 @@ def build(program_path: str,
                            custom_typing_module=custom_typing_module,
                            reports=reports)
 
-    if program_text is None:
-        program_path = program_path or lookup_program(module, lib_path)
-        program_text = read_program(program_path)
-    else:
-        program_path = program_path or '<string>'
-
     # Construct information that describes the initial file. __main__ is the
     # implicit module id and the import context is empty initially ([]).
     info = StateInfo(program_path, module, [], manager)

mypy/main.py

@@ -116,7 +116,7 @@ def process_options(args: List[str]) -> Tuple[str, str, str, Options]:
         elif args[0] == '--custom-typing' and args[1:]:
             options.custom_typing_module = args[1]
             args = args[2:]
-        elif args[0] in ('--html-report', '--old-html-report') and args[1:]:
+        elif is_report(args[0]) and args[1:]:
             report_type = args[0][2:-7]
             report_dir = args[1]
             options.report_dirs[report_type] = report_dir
@@ -149,6 +149,22 @@ def process_options(args: List[str]) -> Tuple[str, str, str, Options]:
     return args[0], None, None, options
 
 
+# Don't generate this from mypy.reports, not all are meant to be public.
+REPORTS = [
+        'html',
+        'old-html',
+        'xslt-html',
+        'xml',
+        'txt',
+        'xslt-txt',
+]
+
+def is_report(arg: str) -> bool:
+    if arg.startswith('--') and arg.endswith('-report'):
+        report_type = arg[2:-7]
+        return report_type in REPORTS
+    return False
+
 def usage(msg: str = None) -> None:
     if msg:
         sys.stderr.write('%s\n' % msg)
@@ -163,7 +179,7 @@ def usage(msg: str = None) -> None:
 Optional arguments:
   -h, --help         print this help message and exit
   --<fmt>-report dir generate a <fmt> report of type precision under dir/
-                     <fmt> may be one of: html, old-html.
+                     <fmt> may be one of: %s
   -m mod             type check module
   -c string          type check string
   --verbose          more verbose messages
@@ -172,7 +188,7 @@ def usage(msg: str = None) -> None:
 
 Environment variables:
   MYPYPATH     additional module search path
-""")
+""" % ', '.join(REPORTS))
     sys.exit(2)
 
 def version() -> None:

mypy/report.py

@@ -1,8 +1,11 @@
 """Classes for producing HTML reports about imprecision."""
 
 from abc import ABCMeta, abstractmethod
+import cgi
+import os
+import shutil
 
-from typing import Callable, Dict, List
+from typing import Callable, Dict, List, cast
 
 from mypy.types import Type
 from mypy.nodes import MypyFile, Node
@@ -13,17 +16,25 @@
 
 
 class Reports:
-    def __init__(self, data_dir: str, report_dirs: Dict[str, str]) -> None:
+    def __init__(self, main_file: str, data_dir: str, report_dirs: Dict[str, str]) -> None:
+        self.main_file = main_file
         self.data_dir = data_dir
         self.reporters = [] # type: List[AbstractReporter]
+        self.named_reporters = {} # type: Dict[str, AbstractReporter]
 
         for report_type, report_dir in sorted(report_dirs.items()):
             self.add_report(report_type, report_dir)
 
     def add_report(self, report_type: str, report_dir: str) -> 'AbstractReporter':
+        try:
+            return self.named_reporters[report_type]
+        except KeyError:
+            pass
         reporter_cls = reporter_classes[report_type]
         reporter = reporter_cls(self, report_dir)
         self.reporters.append(reporter)
+        self.named_reporters[report_type] = reporter
+        return reporter
 
     def file(self, tree: MypyFile, type_map: Dict[Node, Type]) -> None:
         for reporter in self.reporters:
@@ -60,4 +71,212 @@ def on_finish(self) -> None:
         stats.generate_html_index(self.output_dir)
 reporter_classes['old-html'] = OldHtmlReporter
 
-reporter_classes['html'] = reporter_classes['old-html']
+class FileInfo:
+    def __init__(self, name: str, module: str) -> None:
+        self.name = name
+        self.module = module
+        self.counts = [0] * len(stats.precision_names)
+
+    def total(self) -> int:
+        return sum(self.counts)
+
+    def attrib(self) -> Dict[str, str]:
+        return {name: str(val) for name, val in zip(stats.precision_names, self.counts)}
+
+class MemoryXmlReporter(AbstractReporter):
+    """Internal reporter that generates XML in memory.
+
+    This is used by all other XML-based reporters to avoid duplication.
+    """
+
+    def __init__(self, reports: Reports, output_dir: str) -> None:
+        import lxml.etree as etree
+
+        super().__init__(reports, output_dir)
+
+        self.main_file = reports.main_file
+        self.xslt_html_path = os.path.join(reports.data_dir, 'xml', 'mypy-html.xslt')
+        self.xslt_txt_path = os.path.join(reports.data_dir, 'xml', 'mypy-txt.xslt')
+        self.css_html_path = os.path.join(reports.data_dir, 'xml', 'mypy-html.css')
+        xsd_path = os.path.join(reports.data_dir, 'xml', 'mypy.xsd')
+        self.schema = etree.XMLSchema(etree.parse(xsd_path))
+        self.last_xml = None # type: etree._ElementTree
+        self.files = [] # type: List[FileInfo]
+
+    def on_file(self, tree: MypyFile, type_map: Dict[Node, Type]) -> None:
+        import lxml.etree as etree
+
+        self.last_xml = None
+        path = os.path.relpath(tree.path)
+        if stats.is_special_module(path):
+            return
+        if path.startswith('..'):
+            return
+        if 'stubs' in path.split('/'):
+            return
+
+        visitor = stats.StatisticsVisitor(inferred=True, typemap=type_map, all_nodes=True)
+        tree.accept(visitor)
+
+        root = etree.Element('mypy-report-file', name=path, module=tree._fullname)
+        doc = etree.ElementTree(root)
+        file_info = FileInfo(path, tree._fullname)
+
+        with open(path) as input_file:
+            for lineno, line_text in enumerate(input_file, 1):
+                status = visitor.line_map.get(lineno, stats.TYPE_EMPTY)
+                file_info.counts[status] += 1
+                etree.SubElement(root, 'line',
+                                 number=str(lineno),
+                                 precision=stats.precision_names[status],
+                                 content=line_text[:-1])
+        # Assumes a layout similar to what XmlReporter uses.
+        xslt_path = os.path.relpath('mypy-html.xslt', path)
+        xml_pi = etree.ProcessingInstruction('xml', 'version="1.0" encoding="utf-8"')
+        transform_pi = etree.ProcessingInstruction('xml-stylesheet', 'type="text/xsl" href="%s"' % cgi.escape(xslt_path, True))
+        root.addprevious(xml_pi)
+        root.addprevious(transform_pi)
+        self.schema.assertValid(doc)
+
+        self.last_xml = doc
+        self.files.append(file_info)
+
+    def on_finish(self) -> None:
+        import lxml.etree as etree
+
+        self.last_xml = None
+        index_path = os.path.join(self.output_dir, 'index.xml')
+        output_files = sorted(self.files, key=lambda x: x.module)
+
+        root = etree.Element('mypy-report-index', name=self.main_file)
+        doc = etree.ElementTree(root)
+
+        for file_info in output_files:
+            etree.SubElement(root, 'file',
+                             file_info.attrib(),
+                             total=str(file_info.total()),
+                             name=file_info.name,
+                             module=file_info.module)
+        xslt_path = os.path.relpath('mypy-html.xslt', '.')
+        xml_pi = etree.ProcessingInstruction('xml', 'version="1.0" encoding="utf-8"')
+        transform_pi = etree.ProcessingInstruction('xml-stylesheet', 'type="text/xsl" href="%s"' % cgi.escape(xslt_path, True))
+        root.addprevious(xml_pi)
+        root.addprevious(transform_pi)
+        self.schema.assertValid(doc)
+
+        self.last_xml = doc
+
+reporter_classes['memory-xml'] = MemoryXmlReporter
+
+class AbstractXmlReporter(AbstractReporter):
+    """Internal abstract class for reporters that work via XML."""
+
+    def __init__(self, reports: Reports, output_dir: str) -> None:
+        super().__init__(reports, output_dir)
+
+        memory_reporter = reports.add_report('memory-xml', '<memory>')
+        # The dependency will be called first.
+        self.memory_xml = cast(MemoryXmlReporter, memory_reporter)
+
+class XmlReporter(AbstractXmlReporter):
+    """Public reporter that exports XML.
+
+    The produced XML files contain a reference to the absolute path
+    of the html transform, so they will be locally viewable in a browser.
+
+    However, there is a bug in Chrome and all other WebKit-based browsers
+    that makes it fail from file:// URLs but work on http:// URLs.
+    """
+
+    def on_file(self, tree: MypyFile, type_map: Dict[Node, Type]) -> None:
+        last_xml = self.memory_xml.last_xml
+        if last_xml is None:
+            return
+        path = os.path.relpath(tree.path)
+        if path.startswith('..'):
+            return
+        out_path = os.path.join(self.output_dir, 'xml', path + '.xml')
+        stats.ensure_dir_exists(os.path.dirname(out_path))
+        last_xml.write(out_path, encoding='utf-8')
+
+    def on_finish(self) -> None:
+        last_xml = self.memory_xml.last_xml
+        out_path = os.path.join(self.output_dir, 'index.xml')
+        out_xslt = os.path.join(self.output_dir, 'mypy-html.xslt')
+        out_css = os.path.join(self.output_dir, 'mypy-html.css')
+        last_xml.write(out_path, encoding='utf-8')
+        shutil.copyfile(self.memory_xml.xslt_html_path, out_xslt)
+        shutil.copyfile(self.memory_xml.css_html_path, out_css)
+        print('Generated XML report:', os.path.abspath(out_path))
+
+reporter_classes['xml'] = XmlReporter
+
+class XsltHtmlReporter(AbstractXmlReporter):
+    """Public reporter that exports HTML via XSLT.
+
+    This is slightly different than running `xsltproc` on the .xml files,
+    because it passes a parameter to rewrite the links.
+    """
+
+    def __init__(self, reports: Reports, output_dir: str) -> None:
+        import lxml.etree as etree
+
+        super().__init__(reports, output_dir)
+
+        self.xslt_html = etree.XSLT(etree.parse(self.memory_xml.xslt_html_path))
+        self.param_html = etree.XSLT.strparam('html')
+
+    def on_file(self, tree: MypyFile, type_map: Dict[Node, Type]) -> None:
+        last_xml = self.memory_xml.last_xml
+        if last_xml is None:
+            return
+        path = os.path.relpath(tree.path)
+        if path.startswith('..'):
+            return
+        out_path = os.path.join(self.output_dir, 'html', path + '.html')
+        stats.ensure_dir_exists(os.path.dirname(out_path))
+        transformed_html = bytes(self.xslt_html(last_xml, ext=self.param_html))
+        with open(out_path, 'wb') as out_file:
+            out_file.write(transformed_html)
+
+    def on_finish(self) -> None:
+        last_xml = self.memory_xml.last_xml
+        out_path = os.path.join(self.output_dir, 'index.html')
+        out_css = os.path.join(self.output_dir, 'mypy-html.css')
+        transformed_html = bytes(self.xslt_html(last_xml, ext=self.param_html))
+        with open(out_path, 'wb') as out_file:
+            out_file.write(transformed_html)
+        shutil.copyfile(self.memory_xml.css_html_path, out_css)
+        print('Generated HTML report (via XSLT):', os.path.abspath(out_path))
+
+reporter_classes['xslt-html'] = XsltHtmlReporter
+
+class XsltTxtReporter(AbstractXmlReporter):
+    """Public reporter that exports TXT via XSLT.
+
+    Currently this only does the summary, not the individual reports.
+    """
+
+    def __init__(self, reports: Reports, output_dir: str) -> None:
+        import lxml.etree as etree
+
+        super().__init__(reports, output_dir)
+
+        self.xslt_txt = etree.XSLT(etree.parse(self.memory_xml.xslt_txt_path))
+
+    def on_file(self, tree: MypyFile, type_map: Dict[Node, Type]) -> None:
+        pass
+
+    def on_finish(self) -> None:
+        last_xml = self.memory_xml.last_xml
+        out_path = os.path.join(self.output_dir, 'index.txt')
+        stats.ensure_dir_exists(os.path.dirname(out_path))
+        transformed_txt = bytes(self.xslt_txt(last_xml))
+        with open(out_path, 'wb') as out_file:
+            out_file.write(transformed_txt)
+        print('Generated TXT report (via XSLT):', os.path.abspath(out_path))
+
+reporter_classes['xslt-txt'] = XsltTxtReporter
+
+reporter_classes['html'] = reporter_classes['xslt-html']
+reporter_classes['txt'] = reporter_classes['xslt-txt']

mypy/stats.py

@@ -18,9 +18,17 @@
 )
 
 
-TYPE_PRECISE = 0
-TYPE_IMPRECISE = 1
-TYPE_ANY = 2
+TYPE_EMPTY = 0
+TYPE_PRECISE = 1
+TYPE_IMPRECISE = 2
+TYPE_ANY = 3
+
+precision_names = [
+        'empty',
+        'precise',
+        'imprecise',
+        'any',
+]
 
 
 class StatisticsVisitor(TraverserVisitor):
@@ -353,7 +361,7 @@ def generate_html_index(output_dir: str) -> None:
     append('</body></html>')
     with open(path, 'w') as file:
         file.writelines(output)
-    print('Generated HTML report: %s' % os.path.abspath(path))
+    print('Generated HTML report (old): %s' % os.path.abspath(path))
 
 
 def ensure_dir_exists(dir: str) -> None:

setup.py

@@ -51,6 +51,8 @@ def find_data_files(base, globs):
 
 data_files += find_data_files('stubs', ['*.py', '*.pyi'])
 
+data_files += find_data_files('xml', ['*.xsd', '*.xslt', '*.css'])
+
 classifiers = [
     'Development Status :: 2 - Pre-Alpha',
     'Environment :: Console',