| # Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Crocodile HTML output.""" |
| |
| import os |
| import shutil |
| import time |
| import xml.dom |
| |
| |
| class CrocHtmlError(Exception): |
| """Coverage HTML error.""" |
| |
| |
| class HtmlElement(object): |
| """Node in a HTML file.""" |
| |
| def __init__(self, doc, element): |
| """Constructor. |
| |
| Args: |
| doc: XML document object. |
| element: XML element. |
| """ |
| self.doc = doc |
| self.element = element |
| |
| def E(self, name, **kwargs): |
| """Adds a child element. |
| |
| Args: |
| name: Name of element. |
| kwargs: Attributes for element. To use an attribute which is a python |
| reserved word (i.e. 'class'), prefix the attribute name with 'e_'. |
| |
| Returns: |
| The child element. |
| """ |
| he = HtmlElement(self.doc, self.doc.createElement(name)) |
| element = he.element |
| self.element.appendChild(element) |
| |
| for k, v in kwargs.iteritems(): |
| if k.startswith('e_'): |
| # Remove prefix |
| element.setAttribute(k[2:], str(v)) |
| else: |
| element.setAttribute(k, str(v)) |
| |
| return he |
| |
| def Text(self, text): |
| """Adds a text node. |
| |
| Args: |
| text: Text to add. |
| |
| Returns: |
| self. |
| """ |
| t = self.doc.createTextNode(str(text)) |
| self.element.appendChild(t) |
| return self |
| |
| |
| class HtmlFile(object): |
| """HTML file.""" |
| |
| def __init__(self, xml_impl, filename): |
| """Constructor. |
| |
| Args: |
| xml_impl: DOMImplementation to use to create document. |
| filename: Path to file. |
| """ |
| self.xml_impl = xml_impl |
| doctype = xml_impl.createDocumentType( |
| 'HTML', '-//W3C//DTD HTML 4.01//EN', |
| 'http://www.w3.org/TR/html4/strict.dtd') |
| self.doc = xml_impl.createDocument(None, 'html', doctype) |
| self.filename = filename |
| |
| # Create head and body elements |
| root = HtmlElement(self.doc, self.doc.documentElement) |
| self.head = root.E('head') |
| self.body = root.E('body') |
| |
| def Write(self, cleanup=True): |
| """Writes the file. |
| |
| Args: |
| cleanup: If True, calls unlink() on the internal xml document. This |
| frees up memory, but means that you can't use this file for anything |
| else. |
| """ |
| f = open(self.filename, 'wt') |
| self.doc.writexml(f, encoding='UTF-8') |
| f.close() |
| |
| if cleanup: |
| self.doc.unlink() |
| # Prevent future uses of the doc now that we've unlinked it |
| self.doc = None |
| |
| #------------------------------------------------------------------------------ |
| |
| COV_TYPE_STRING = {None: 'm', 0: 'i', 1: 'E', 2: ' '} |
| COV_TYPE_CLASS = {None: 'missing', 0: 'instr', 1: 'covered', 2: ''} |
| |
| |
| class CrocHtml(object): |
| """Crocodile HTML output class.""" |
| |
| def __init__(self, cov, output_root, base_url=None): |
| """Constructor.""" |
| self.cov = cov |
| self.output_root = output_root |
| self.base_url = base_url |
| self.xml_impl = xml.dom.getDOMImplementation() |
| self.time_string = 'Coverage information generated %s.' % time.asctime() |
| |
| def CreateHtmlDoc(self, filename, title): |
| """Creates a new HTML document. |
| |
| Args: |
| filename: Filename to write to, relative to self.output_root. |
| title: Title of page |
| |
| Returns: |
| The document. |
| """ |
| f = HtmlFile(self.xml_impl, self.output_root + '/' + filename) |
| |
| f.head.E('title').Text(title) |
| |
| if self.base_url: |
| css_href = self.base_url + 'croc.css' |
| base_href = self.base_url + os.path.dirname(filename) |
| if not base_href.endswith('/'): |
| base_href += '/' |
| f.head.E('base', href=base_href) |
| else: |
| css_href = '../' * (len(filename.split('/')) - 1) + 'croc.css' |
| |
| f.head.E('link', rel='stylesheet', type='text/css', href=css_href) |
| |
| return f |
| |
| def AddCaptionForFile(self, body, path): |
| """Adds a caption for the file, with links to each parent dir. |
| |
| Args: |
| body: Body elemement. |
| path: Path to file. |
| """ |
| # This is slightly different that for subdir, because it needs to have a |
| # link to the current directory's index.html. |
| hdr = body.E('h2') |
| hdr.Text('Coverage for ') |
| dirs = [''] + path.split('/') |
| num_dirs = len(dirs) |
| for i in range(num_dirs - 1): |
| hdr.E('a', href=( |
| '../' * (num_dirs - i - 2) + 'index.html')).Text(dirs[i] + '/') |
| hdr.Text(dirs[-1]) |
| |
| def AddCaptionForSubdir(self, body, path): |
| """Adds a caption for the subdir, with links to each parent dir. |
| |
| Args: |
| body: Body elemement. |
| path: Path to subdir. |
| """ |
| # Link to parent dirs |
| hdr = body.E('h2') |
| hdr.Text('Coverage for ') |
| dirs = [''] + path.split('/') |
| num_dirs = len(dirs) |
| for i in range(num_dirs - 1): |
| hdr.E('a', href=( |
| '../' * (num_dirs - i - 1) + 'index.html')).Text(dirs[i] + '/') |
| hdr.Text(dirs[-1] + '/') |
| |
| def AddSectionHeader(self, table, caption, itemtype, is_file=False): |
| """Adds a section header to the coverage table. |
| |
| Args: |
| table: Table to add rows to. |
| caption: Caption for section, if not None. |
| itemtype: Type of items in this section, if not None. |
| is_file: Are items in this section files? |
| """ |
| |
| if caption is not None: |
| table.E('tr').E('th', e_class='secdesc', colspan=8).Text(caption) |
| |
| sec_hdr = table.E('tr') |
| |
| if itemtype is not None: |
| sec_hdr.E('th', e_class='section').Text(itemtype) |
| |
| sec_hdr.E('th', e_class='section').Text('Coverage') |
| sec_hdr.E('th', e_class='section', colspan=3).Text( |
| 'Lines executed / instrumented / missing') |
| |
| graph = sec_hdr.E('th', e_class='section') |
| graph.E('span', style='color:#00FF00').Text('exe') |
| graph.Text(' / ') |
| graph.E('span', style='color:#FFFF00').Text('inst') |
| graph.Text(' / ') |
| graph.E('span', style='color:#FF0000').Text('miss') |
| |
| if is_file: |
| sec_hdr.E('th', e_class='section').Text('Language') |
| sec_hdr.E('th', e_class='section').Text('Group') |
| else: |
| sec_hdr.E('th', e_class='section', colspan=2) |
| |
| def AddItem(self, table, itemname, stats, attrs, link=None): |
| """Adds a bar graph to the element. This is a series of <td> elements. |
| |
| Args: |
| table: Table to add item to. |
| itemname: Name of item. |
| stats: Stats object. |
| attrs: Attributes dictionary; if None, no attributes will be printed. |
| link: Destination for itemname hyperlink, if not None. |
| """ |
| row = table.E('tr') |
| |
| # Add item name |
| if itemname is not None: |
| item_elem = row.E('td') |
| if link is not None: |
| item_elem = item_elem.E('a', href=link) |
| item_elem.Text(itemname) |
| |
| # Get stats |
| stat_exe = stats.get('lines_executable', 0) |
| stat_ins = stats.get('lines_instrumented', 0) |
| stat_cov = stats.get('lines_covered', 0) |
| |
| percent = row.E('td') |
| |
| # Add text |
| row.E('td', e_class='number').Text(stat_cov) |
| row.E('td', e_class='number').Text(stat_ins) |
| row.E('td', e_class='number').Text(stat_exe - stat_ins) |
| |
| # Add percent and graph; only fill in if there's something in there |
| graph = row.E('td', e_class='graph', width=100) |
| if stat_exe: |
| percent_cov = 100.0 * stat_cov / stat_exe |
| percent_ins = 100.0 * stat_ins / stat_exe |
| |
| # Color percent based on thresholds |
| percent.Text('%.1f%%' % percent_cov) |
| if percent_cov >= 80: |
| percent.element.setAttribute('class', 'high_pct') |
| elif percent_cov >= 60: |
| percent.element.setAttribute('class', 'mid_pct') |
| else: |
| percent.element.setAttribute('class', 'low_pct') |
| |
| # Graphs use integer values |
| percent_cov = int(percent_cov) |
| percent_ins = int(percent_ins) |
| |
| graph.Text('.') |
| graph.E('span', style='padding-left:%dpx' % percent_cov, |
| e_class='g_covered') |
| graph.E('span', style='padding-left:%dpx' % (percent_ins - percent_cov), |
| e_class='g_instr') |
| graph.E('span', style='padding-left:%dpx' % (100 - percent_ins), |
| e_class='g_missing') |
| |
| if attrs: |
| row.E('td', e_class='stat').Text(attrs.get('language')) |
| row.E('td', e_class='stat').Text(attrs.get('group')) |
| else: |
| row.E('td', colspan=2) |
| |
| def WriteFile(self, cov_file): |
| """Writes the HTML for a file. |
| |
| Args: |
| cov_file: croc.CoveredFile to write. |
| """ |
| print ' ' + cov_file.filename |
| title = 'Coverage for ' + cov_file.filename |
| |
| f = self.CreateHtmlDoc(cov_file.filename + '.html', title) |
| body = f.body |
| |
| # Write header section |
| self.AddCaptionForFile(body, cov_file.filename) |
| |
| # Summary for this file |
| table = body.E('table') |
| self.AddSectionHeader(table, None, None, is_file=True) |
| self.AddItem(table, None, cov_file.stats, cov_file.attrs) |
| |
| body.E('h2').Text('Line-by-line coverage:') |
| |
| # Print line-by-line coverage |
| if cov_file.local_path: |
| code_table = body.E('table').E('tr').E('td').E('pre') |
| |
| flines = open(cov_file.local_path, 'rt') |
| lineno = 0 |
| |
| for line in flines: |
| lineno += 1 |
| line_cov = cov_file.lines.get(lineno, 2) |
| e_class = COV_TYPE_CLASS.get(line_cov) |
| |
| code_table.E('span', e_class=e_class).Text('%4d %s : %s\n' % ( |
| lineno, |
| COV_TYPE_STRING.get(line_cov), |
| line.rstrip() |
| )) |
| |
| else: |
| body.Text('Line-by-line coverage not available. Make sure the directory' |
| ' containing this file has been scanned via ') |
| body.E('B').Text('add_files') |
| body.Text(' in a configuration file, or the ') |
| body.E('B').Text('--addfiles') |
| body.Text(' command line option.') |
| |
| # TODO: if file doesn't have a local path, try to find it by |
| # reverse-mapping roots and searching for the file. |
| |
| body.E('p', e_class='time').Text(self.time_string) |
| f.Write() |
| |
| def WriteSubdir(self, cov_dir): |
| """Writes the index.html for a subdirectory. |
| |
| Args: |
| cov_dir: croc.CoveredDir to write. |
| """ |
| print ' ' + cov_dir.dirpath + '/' |
| |
| # Create the subdir if it doesn't already exist |
| subdir = self.output_root + '/' + cov_dir.dirpath |
| if not os.path.exists(subdir): |
| os.mkdir(subdir) |
| |
| if cov_dir.dirpath: |
| title = 'Coverage for ' + cov_dir.dirpath + '/' |
| f = self.CreateHtmlDoc(cov_dir.dirpath + '/index.html', title) |
| else: |
| title = 'Coverage summary' |
| f = self.CreateHtmlDoc('index.html', title) |
| |
| body = f.body |
| |
| dirs = [''] + cov_dir.dirpath.split('/') |
| num_dirs = len(dirs) |
| sort_jsfile = '../' * (num_dirs - 1) + 'sorttable.js' |
| script = body.E('script', src=sort_jsfile) |
| body.E('/script') |
| |
| # Write header section |
| if cov_dir.dirpath: |
| self.AddCaptionForSubdir(body, cov_dir.dirpath) |
| else: |
| body.E('h2').Text(title) |
| |
| table = body.E('table', e_class='sortable') |
| table.E('h3').Text('Coverage by Group') |
| # Coverage by group |
| self.AddSectionHeader(table, None, 'Group') |
| |
| for group in sorted(cov_dir.stats_by_group): |
| self.AddItem(table, group, cov_dir.stats_by_group[group], None) |
| |
| # List subdirs |
| if cov_dir.subdirs: |
| table = body.E('table', e_class='sortable') |
| table.E('h3').Text('Subdirectories') |
| self.AddSectionHeader(table, None, 'Subdirectory') |
| |
| for d in sorted(cov_dir.subdirs): |
| self.AddItem(table, d + '/', cov_dir.subdirs[d].stats_by_group['all'], |
| None, link=d + '/index.html') |
| |
| # List files |
| if cov_dir.files: |
| table = body.E('table', e_class='sortable') |
| table.E('h3').Text('Files in This Directory') |
| self.AddSectionHeader(table, None, 'Filename', |
| is_file=True) |
| |
| for filename in sorted(cov_dir.files): |
| cov_file = cov_dir.files[filename] |
| self.AddItem(table, filename, cov_file.stats, cov_file.attrs, |
| link=filename + '.html') |
| |
| body.E('p', e_class='time').Text(self.time_string) |
| f.Write() |
| |
| def WriteRoot(self): |
| """Writes the files in the output root.""" |
| # Find ourselves |
| src_dir = os.path.split(self.WriteRoot.func_code.co_filename)[0] |
| |
| # Files to copy into output root |
| copy_files = ['croc.css'] |
| # Third_party files to copy into output root |
| third_party_files = ['sorttable.js'] |
| |
| # Copy files from our directory into the output directory |
| for copy_file in copy_files: |
| print ' Copying %s' % copy_file |
| shutil.copyfile(os.path.join(src_dir, copy_file), |
| os.path.join(self.output_root, copy_file)) |
| # Copy third party files from third_party directory into |
| # the output directory |
| src_dir = os.path.join(src_dir, 'third_party') |
| for third_party_file in third_party_files: |
| print ' Copying %s' % third_party_file |
| shutil.copyfile(os.path.join(src_dir, third_party_file), |
| os.path.join(self.output_root, third_party_file)) |
| |
| def Write(self): |
| """Writes HTML output.""" |
| |
| print 'Writing HTML to %s...' % self.output_root |
| |
| # Loop through the tree and write subdirs, breadth-first |
| # TODO: switch to depth-first and sort values - makes nicer output? |
| todo = [self.cov.tree] |
| while todo: |
| cov_dir = todo.pop(0) |
| |
| # Append subdirs to todo list |
| todo += cov_dir.subdirs.values() |
| |
| # Write this subdir |
| self.WriteSubdir(cov_dir) |
| |
| # Write files in this subdir |
| for cov_file in cov_dir.files.itervalues(): |
| self.WriteFile(cov_file) |
| |
| # Write files in root directory |
| self.WriteRoot() |
