eric: comparison eric7/DebugClients/Python/coverage/html.py

-:d728227e8ebb
+:0802ae193343
 import datetime
 import json
 import os
 import re
 import shutil
+import types
 import coverage
-from coverage import env
-from coverage.backward import iitems, SimpleNamespace, format_local_datetime
 from coverage.data import add_data_to_hash
+from coverage.exceptions import CoverageException
 from coverage.files import flat_rootname
-from coverage.misc import CoverageException, ensure_dir, file_be_gone, Hasher, isolate_module
+from coverage.misc import ensure_dir, file_be_gone, Hasher, isolate_module, format_local_datetime
+from coverage.misc import human_sorted
 from coverage.report import get_analysis_to_report
 from coverage.results import Numbers
 from coverage.templite import Templite
 os = isolate_module(os)
-# Static files are looked for in a list of places.
+def data_filename(fname):
-STATIC_PATH = [
+"""Return the path to an "htmlfiles" data file of ours.
-# The place Debian puts system Javascript libraries.
-"/usr/share/javascript",
-# Our htmlfiles directory.
-os.path.join(os.path.dirname(__file__), "htmlfiles"),
-]
-def data_filename(fname, pkgdir=""):
-"""Return the path to a data file of ours.
-The file is searched for on `STATIC_PATH`, and the first place it's found,
-is returned.
-Each directory in `STATIC_PATH` is searched as-is, and also, if `pkgdir`
-is provided, at that sub-directory.
 """
-tried = []
+static_dir = os.path.join(os.path.dirname(__file__), "htmlfiles")
-for static_dir in STATIC_PATH:
+static_filename = os.path.join(static_dir, fname)
-static_filename = os.path.join(static_dir, fname)
+return static_filename
-if os.path.exists(static_filename):
-return static_filename
-else:
-tried.append(static_filename)
-if pkgdir:
-static_filename = os.path.join(static_dir, pkgdir, fname)
-if os.path.exists(static_filename):
-return static_filename
-else:
-tried.append(static_filename)
-raise CoverageException(
-"Couldn't find static file %r from %r, tried: %r" % (fname, os.getcwd(), tried)
-)
 def read_data(fname):
 """Return the contents of a data file of ours."""
 with open(data_filename(fname)) as data_file:
 html = re.sub(r"(\A\s+)|(\s+$)", "", html, flags=re.MULTILINE) + "\n"
 with open(fname, "wb") as fout:
 fout.write(html.encode('ascii', 'xmlcharrefreplace'))
-class HtmlDataGeneration(object):
+class HtmlDataGeneration:
 """Generate structured data to be turned into HTML reports."""
 EMPTY = "(empty)"
 def __init__(self, cov):
 category = 'run'
 contexts = contexts_label = None
 context_list = None
 if category and self.config.show_contexts:
-contexts = sorted(c or self.EMPTY for c in contexts_by_lineno[lineno])
+contexts = human_sorted(c or self.EMPTY for c in contexts_by_lineno.get(lineno, ()))
 if contexts == [self.EMPTY]:
 contexts_label = self.EMPTY
 else:
-contexts_label = "{} ctx".format(len(contexts))
+contexts_label = f"{len(contexts)} ctx"
 context_list = contexts
-lines.append(SimpleNamespace(
+lines.append(types.SimpleNamespace(
 tokens=tokens,
 number=lineno,
 category=category,
 statement=(lineno in analysis.statements),
 contexts=contexts,
 context_list=context_list,
 short_annotations=short_annotations,
 long_annotations=long_annotations,
 ))
-file_data = SimpleNamespace(
+file_data = types.SimpleNamespace(
 relative_filename=fr.relative_filename(),
 nums=analysis.numbers,
 lines=lines,
 )
 return file_data
-class HtmlReporter(object):
+class HtmlReporter:
 """HTML reporting."""
 # These files will be copied from the htmlfiles directory to the output
 # directory.
 STATIC_FILES = [
-("style.css", ""),
+"style.css",
-("jquery.min.js", "jquery"),
+"coverage_html.js",
-("jquery.ba-throttle-debounce.min.js", "jquery-throttle-debounce"),
+"keybd_closed.png",
-("jquery.hotkeys.js", "jquery-hotkeys"),
+"keybd_open.png",
-("jquery.isonscreen.js", "jquery-isonscreen"),
+"favicon_32.png",
-("jquery.tablesorter.min.js", "jquery-tablesorter"),
-("coverage_html.js", ""),
-("keybd_closed.png", ""),
-("keybd_open.png", ""),
-("favicon_32.png", ""),
 ]
 def __init__(self, cov):
 self.coverage = cov
 self.config = self.coverage.config
 self.skip_covered = self.config.html_skip_covered
 if self.skip_covered is None:
 self.skip_covered = self.config.skip_covered
 self.skip_empty = self.config.html_skip_empty
 if self.skip_empty is None:
-self.skip_empty= self.config.skip_empty
+self.skip_empty = self.config.skip_empty
+self.skipped_covered_count = 0
+self.skipped_empty_count = 0
 title = self.config.html_title
-if env.PY2:
-title = title.decode("utf8")
 if self.config.extra_css:
 self.extra_css = os.path.basename(self.config.extra_css)
 else:
 self.extra_css = None
 self.file_summaries = []
 self.all_files_nums = []
 self.incr = IncrementalChecker(self.directory)
 self.datagen = HtmlDataGeneration(self.coverage)
-self.totals = Numbers()
+self.totals = Numbers(precision=self.config.precision)
 self.template_globals = {
 # Functions available in the templates.
 'escape': escape,
 'pair': pair,
 return self.totals.n_statements and self.totals.pc_covered
 def make_local_static_report_files(self):
 """Make local instances of static files for HTML report."""
 # The files we provide must always be copied.
-for static, pkgdir in self.STATIC_FILES:
+for static in self.STATIC_FILES:
-shutil.copyfile(
+shutil.copyfile(data_filename(static), os.path.join(self.directory, static))
-data_filename(static, pkgdir),
-os.path.join(self.directory, static)
+# .gitignore can't be copied from the source tree because it would
-)
+# prevent the static files from being checked in.
+with open(os.path.join(self.directory, ".gitignore"), "w") as fgi:
+fgi.write("# Created by coverage.py\n*\n")
 # The user may have extra CSS they want copied.
 if self.extra_css:
-shutil.copyfile(
+shutil.copyfile(self.config.extra_css, os.path.join(self.directory, self.extra_css))
-self.config.extra_css,
-os.path.join(self.directory, self.extra_css)
-)
 def html_file(self, fr, analysis):
 """Generate an HTML file for one source file."""
 rootname = flat_rootname(fr.relative_filename())
 html_filename = rootname + ".html"
 no_missing_lines = (nums.n_missing == 0)
 no_missing_branches = (nums.n_partial_branches == 0)
 if no_missing_lines and no_missing_branches:
 # If there's an existing file, remove it.
 file_be_gone(html_path)
+self.skipped_covered_count += 1
 return
 if self.skip_empty:
 # Don't report on empty files.
 if nums.n_statements == 0:
 file_be_gone(html_path)
+self.skipped_empty_count += 1
 return
 # Find out if the file on disk is already correct.
 if self.incr.can_skip_file(self.data, fr, rootname):
 self.file_summaries.append(self.incr.index_info(rootname))
 if tok_type == "ws":
 html.append(escape(tok_text))
 else:
 tok_html = escape(tok_text) or '&nbsp;'
 html.append(
-u'<span class="{}">{}</span>'.format(tok_type, tok_html)
+f'<span class="{tok_type}">{tok_html}</span>'
 )
 ldata.html = ''.join(html)
 if ldata.short_annotations:
 # 202F is NARROW NO-BREAK SPACE.
 # 219B is RIGHTWARDS ARROW WITH STROKE.
-ldata.annotate = u",&nbsp;&nbsp; ".join(
+ldata.annotate = ",&nbsp;&nbsp; ".join(
-u"{}&#x202F;&#x219B;&#x202F;{}".format(ldata.number, d)
+f"{ldata.number}&#x202F;&#x219B;&#x202F;{d}"
 for d in ldata.short_annotations
 )
 else:
 ldata.annotate = None
 if ldata.long_annotations:
 longs = ldata.long_annotations
 if len(longs) == 1:
 ldata.annotate_long = longs[0]
 else:
-ldata.annotate_long = u"{:d} missed branches: {}".format(
+ldata.annotate_long = "{:d} missed branches: {}".format(
 len(longs),
-u", ".join(
+", ".join(
-u"{:d}) {}".format(num, ann_long)
+f"{num:d}) {ann_long}"
 for num, ann_long in enumerate(longs, start=1)
 ),
 )
 else:
 ldata.annotate_long = None
 def index_file(self):
 """Write the index.html file for this report."""
 index_tmpl = Templite(read_data("index.html"), self.template_globals)
+skipped_covered_msg = skipped_empty_msg = ""
+if self.skipped_covered_count:
+msg = "{} {} skipped due to complete coverage."
+skipped_covered_msg = msg.format(
+self.skipped_covered_count,
+"file" if self.skipped_covered_count == 1 else "files",
+)
+if self.skipped_empty_count:
+msg = "{} empty {} skipped."
+skipped_empty_msg = msg.format(
+self.skipped_empty_count,
+"file" if self.skipped_empty_count == 1 else "files",
+)
 html = index_tmpl.render({
 'files': self.file_summaries,
 'totals': self.totals,
+'skipped_covered_msg': skipped_covered_msg,
+'skipped_empty_msg': skipped_empty_msg,
 })
-write_html(os.path.join(self.directory, "index.html"), html)
+index_file = os.path.join(self.directory, "index.html")
+write_html(index_file, html)
+self.coverage._message(f"Wrote HTML report to {index_file}")
 # Write the latest hashes for next time.
 self.incr.write()
-class IncrementalChecker(object):
+class IncrementalChecker:
 """Logic and data to support incremental reporting."""
 STATUS_FILE = "status.json"
 STATUS_FORMAT = 2
 usable = False
 try:
 status_file = os.path.join(self.directory, self.STATUS_FILE)
 with open(status_file) as fstatus:
 status = json.load(fstatus)
-except (IOError, ValueError):
+except (OSError, ValueError):
 usable = False
 else:
 usable = True
 if status['format'] != self.STATUS_FORMAT:
 usable = False
 elif status['version'] != coverage.__version__:
 usable = False
 if usable:
 self.files = {}
-for filename, fileinfo in iitems(status['files']):
+for filename, fileinfo in status['files'].items():
 fileinfo['index']['nums'] = Numbers(*fileinfo['index']['nums'])
 self.files[filename] = fileinfo
 self.globals = status['globals']
 else:
 self.reset()
 def write(self):
 """Write the current status."""
 status_file = os.path.join(self.directory, self.STATUS_FILE)
 files = {}
-for filename, fileinfo in iitems(self.files):
+for filename, fileinfo in self.files.items():
 fileinfo['index']['nums'] = fileinfo['index']['nums'].init_args()
 files[filename] = fileinfo
 status = {
 'format': self.STATUS_FORMAT,

Mercurial Repositories > eric / file comparison

comparison: eric7/DebugClients/Python/coverage/html.py

eric7/DebugClients/Python/coverage/html.py