File Manager

X7ROOT File Manager

Current Path: /usr/lib64/python2.7/site-packages/coverage

usr / lib64 / python2.7 / site-packages / coverage /

📁 ..
📄 __init__.py(4.4 KB)
📄 __init__.pyc(2.29 KB)
📄 __init__.pyo(2.29 KB)
📄 __main__.py(100 B)
📄 __main__.pyc(308 B)
📄 __main__.pyo(308 B)
📄 annotate.py(2.92 KB)
📄 annotate.pyc(3.1 KB)
📄 annotate.pyo(3.1 KB)
📄 backward.py(3.97 KB)
📄 backward.pyc(4.3 KB)
📄 backward.pyo(4.3 KB)
📄 bytecode.py(2.27 KB)
📄 bytecode.pyc(3.29 KB)
📄 bytecode.pyo(3.29 KB)
📄 cmdline.py(24.16 KB)
📄 cmdline.pyc(20.01 KB)
📄 cmdline.pyo(19.96 KB)
📄 codeunit.py(4.34 KB)
📄 codeunit.pyc(5.19 KB)
📄 codeunit.pyo(5.19 KB)
📄 collector.py(12.7 KB)
📄 collector.pyc(9.14 KB)
📄 collector.pyo(9.08 KB)
📄 config.py(6.86 KB)
📄 config.pyc(7.67 KB)
📄 config.pyo(7.67 KB)
📄 control.py(26.58 KB)
📄 control.pyc(21.95 KB)
📄 control.pyo(21.95 KB)
📄 data.py(8.63 KB)
📄 data.pyc(9.65 KB)
📄 data.pyo(9.65 KB)
📄 execfile.py(4.78 KB)
📄 execfile.pyc(3.45 KB)
📄 execfile.pyo(3.45 KB)
📄 files.py(9.8 KB)
📄 files.pyc(10.62 KB)
📄 files.pyo(10.62 KB)
📄 html.py(11.84 KB)
📄 html.pyc(11.24 KB)
📄 html.pyo(11.15 KB)
📁 htmlfiles
📄 misc.py(4.08 KB)
📄 misc.pyc(6.13 KB)
📄 misc.pyo(6.13 KB)
📄 parser.py(23.65 KB)
📄 parser.pyc(17.16 KB)
📄 parser.pyo(17 KB)
📄 phystokens.py(7.07 KB)
📄 phystokens.pyc(5.3 KB)
📄 phystokens.pyo(5.24 KB)
📄 report.py(2.96 KB)
📄 report.pyc(2.86 KB)
📄 report.pyo(2.86 KB)
📄 results.py(8.86 KB)
📄 results.pyc(9.29 KB)
📄 results.pyo(9.23 KB)
📄 summary.py(2.9 KB)
📄 summary.pyc(2.88 KB)
📄 summary.pyo(2.88 KB)
📄 templite.py(5.57 KB)
📄 templite.pyc(4.8 KB)
📄 templite.pyo(4.61 KB)
📄 tracer.so(15.91 KB)
📄 version.py(336 B)
📄 version.pyc(361 B)
📄 version.pyo(361 B)
📄 xmlreport.py(5.57 KB)
📄 xmlreport.pyc(4.86 KB)
📄 xmlreport.pyo(4.86 KB)

Editing: html.py

"""HTML reporting for Coverage."""

import os, re, shutil, sys

import coverage
from coverage.backward import pickle
from coverage.misc import CoverageException, Hasher
from coverage.phystokens import source_token_lines, source_encoding
from coverage.report import Reporter
from coverage.results import Numbers
from coverage.templite import Templite

# Disable pylint msg W0612, because a bunch of variables look unused, but
# they're accessed in a Templite context via locals().
# pylint: disable=W0612

def data_filename(fname):
    """Return the path to a data file of ours."""
    return os.path.join(os.path.split(__file__)[0], fname)

def data(fname):
    """Return the contents of a data file of ours."""
    data_file = open(data_filename(fname))
    try:
        return data_file.read()
    finally:
        data_file.close()

class HtmlReporter(Reporter):
    """HTML reporting."""

# These files will be copied from the htmlfiles dir to the output dir.
    STATIC_FILES = [
            "style.css",
            "jquery-1.4.3.min.js",
            "jquery.hotkeys.js",
            "jquery.isonscreen.js",
            "jquery.tablesorter.min.js",
            "coverage_html.js",
            "keybd_closed.png",
            "keybd_open.png",
            ]

def __init__(self, cov, config):
        super(HtmlReporter, self).__init__(cov, config)
        self.directory = None
        self.template_globals = {
            'escape': escape,
            'title': self.config.html_title,
            '__url__': coverage.__url__,
            '__version__': coverage.__version__,
            }
        self.source_tmpl = Templite(
            data("htmlfiles/pyfile.html"), self.template_globals
            )

self.coverage = cov

self.files = []
        self.arcs = self.coverage.data.has_arcs()
        self.status = HtmlStatus()
        self.extra_css = None
        self.totals = Numbers()

def report(self, morfs):
        """Generate an HTML report for `morfs`.

`morfs` is a list of modules or filenames.

"""
        assert self.config.html_dir, "must give a directory for html reporting"

# Read the status data.
        self.status.read(self.config.html_dir)

# Check that this run used the same settings as the last run.
        m = Hasher()
        m.update(self.config)
        these_settings = m.digest()
        if self.status.settings_hash() != these_settings:
            self.status.reset()
            self.status.set_settings_hash(these_settings)

# The user may have extra CSS they want copied.
        if self.config.extra_css:
            self.extra_css = os.path.basename(self.config.extra_css)

# Process all the files.
        self.report_files(self.html_file, morfs, self.config.html_dir)

if not self.files:
            raise CoverageException("No data to report.")

# Write the index file.
        self.index_file()

self.make_local_static_report_files()

return 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 in self.STATIC_FILES:
            shutil.copyfile(
                data_filename("htmlfiles/" + static),
                os.path.join(self.directory, static)
                )

# The user may have extra CSS they want copied.
        if self.extra_css:
            shutil.copyfile(
                self.config.extra_css,
                os.path.join(self.directory, self.extra_css)
                )

def write_html(self, fname, html):
        """Write `html` to `fname`, properly encoded."""
        fout = open(fname, "wb")
        try:
            fout.write(html.encode('ascii', 'xmlcharrefreplace'))
        finally:
            fout.close()

def file_hash(self, source, cu):
        """Compute a hash that changes if the file needs to be re-reported."""
        m = Hasher()
        m.update(source)
        self.coverage.data.add_to_hash(cu.filename, m)
        return m.digest()

def html_file(self, cu, analysis):
        """Generate an HTML file for one source file."""
        source_file = cu.source_file()
        try:
            source = source_file.read()
        finally:
            source_file.close()

# Find out if the file on disk is already correct.
        flat_rootname = cu.flat_rootname()
        this_hash = self.file_hash(source, cu)
        that_hash = self.status.file_hash(flat_rootname)
        if this_hash == that_hash:
            # Nothing has changed to require the file to be reported again.
            self.files.append(self.status.index_info(flat_rootname))
            return

self.status.set_file_hash(flat_rootname, this_hash)

# If need be, determine the encoding of the source file. We use it
        # later to properly write the HTML.
        if sys.version_info < (3, 0):
            encoding = source_encoding(source)
            # Some UTF8 files have the dreaded UTF8 BOM. If so, junk it.
            if encoding.startswith("utf-8") and source[:3] == "\xef\xbb\xbf":
                source = source[3:]
                encoding = "utf-8"

# Get the numbers for this file.
        nums = analysis.numbers

missing_branch_arcs = analysis.missing_branch_arcs()
        arcs = self.arcs

# These classes determine which lines are highlighted by default.
        c_run = "run hide_run"
        c_exc = "exc"
        c_mis = "mis"
        c_par = "par " + c_run

lines = []

for lineno, line in enumerate(source_token_lines(source)):
            lineno += 1     # 1-based line numbers.
            # Figure out how to mark this line.
            line_class = []
            annotate_html = ""
            annotate_title = ""
            if lineno in analysis.statements:
                line_class.append("stm")
            if lineno in analysis.excluded:
                line_class.append(c_exc)
            elif lineno in analysis.missing:
                line_class.append(c_mis)
            elif self.arcs and lineno in missing_branch_arcs:
                line_class.append(c_par)
                annlines = []
                for b in missing_branch_arcs[lineno]:
                    if b < 0:
                        annlines.append("exit")
                    else:
                        annlines.append(str(b))
                annotate_html = "&nbsp;&nbsp; ".join(annlines)
                if len(annlines) > 1:
                    annotate_title = "no jumps to these line numbers"
                elif len(annlines) == 1:
                    annotate_title = "no jump to this line number"
            elif lineno in analysis.statements:
                line_class.append(c_run)

# Build the HTML for the line
            html = []
            for tok_type, tok_text in line:
                if tok_type == "ws":
                    html.append(escape(tok_text))
                else:
                    tok_html = escape(tok_text) or '&nbsp;'
                    html.append(
                        "<span class='%s'>%s</span>" % (tok_type, tok_html)
                        )

lines.append({
                'html': ''.join(html),
                'number': lineno,
                'class': ' '.join(line_class) or "pln",
                'annotate': annotate_html,
                'annotate_title': annotate_title,
            })

# Write the HTML page for this file.
        html_filename = flat_rootname + ".html"
        html_path = os.path.join(self.directory, html_filename)
        extra_css = self.extra_css

html = spaceless(self.source_tmpl.render(locals()))
        if sys.version_info < (3, 0):
            html = html.decode(encoding)
        self.write_html(html_path, html)

# Save this file's information for the index file.
        index_info = {
            'nums': nums,
            'html_filename': html_filename,
            'name': cu.name,
            }
        self.files.append(index_info)
        self.status.set_index_info(flat_rootname, index_info)

def index_file(self):
        """Write the index.html file for this report."""
        index_tmpl = Templite(
            data("htmlfiles/index.html"), self.template_globals
            )

files = self.files
        arcs = self.arcs

self.totals = totals = sum([f['nums'] for f in files])
        extra_css = self.extra_css

html = index_tmpl.render(locals())
        if sys.version_info < (3, 0):
            html = html.decode("utf-8")
        self.write_html(
            os.path.join(self.directory, "index.html"),
            html
            )

# Write the latest hashes for next time.
        self.status.write(self.directory)

class HtmlStatus(object):
    """The status information we keep to support incremental reporting."""

STATUS_FILE = "status.dat"
    STATUS_FORMAT = 1

def __init__(self):
        self.reset()

def reset(self):
        """Initialize to empty."""
        self.settings = ''
        self.files = {}

def read(self, directory):
        """Read the last status in `directory`."""
        usable = False
        try:
            status_file = os.path.join(directory, self.STATUS_FILE)
            fstatus = open(status_file, "rb")
            try:
                status = pickle.load(fstatus)
            finally:
                fstatus.close()
        except (IOError, 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 = status['files']
            self.settings = status['settings']
        else:
            self.reset()

def write(self, directory):
        """Write the current status to `directory`."""
        status_file = os.path.join(directory, self.STATUS_FILE)
        status = {
            'format': self.STATUS_FORMAT,
            'version': coverage.__version__,
            'settings': self.settings,
            'files': self.files,
            }
        fout = open(status_file, "wb")
        try:
            pickle.dump(status, fout)
        finally:
            fout.close()

def settings_hash(self):
        """Get the hash of the coverage.py settings."""
        return self.settings

def set_settings_hash(self, settings):
        """Set the hash of the coverage.py settings."""
        self.settings = settings

def file_hash(self, fname):
        """Get the hash of `fname`'s contents."""
        return self.files.get(fname, {}).get('hash', '')

def set_file_hash(self, fname, val):
        """Set the hash of `fname`'s contents."""
        self.files.setdefault(fname, {})['hash'] = val

def index_info(self, fname):
        """Get the information for index.html for `fname`."""
        return self.files.get(fname, {}).get('index', {})

def set_index_info(self, fname, info):
        """Set the information for index.html for `fname`."""
        self.files.setdefault(fname, {})['index'] = info

# Helpers for templates and generating HTML

def escape(t):
    """HTML-escape the text in `t`."""
    return (t
            # Convert HTML special chars into HTML entities.
            .replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
            .replace("'", "&#39;").replace('"', "&quot;")
            # Convert runs of spaces: "......" -> "&nbsp;.&nbsp;.&nbsp;."
            .replace("  ", "&nbsp; ")
            # To deal with odd-length runs, convert the final pair of spaces
            # so that "....." -> "&nbsp;.&nbsp;&nbsp;."
            .replace("  ", "&nbsp; ")
        )

def spaceless(html):
    """Squeeze out some annoying extra space from an HTML string.

Nicely-formatted templates mean lots of extra space in the result.
    Get rid of some.

"""
    html = re.sub(r">\s+<p ", ">\n<p ", html)
    return html

X7ROOT File Manager

Editing: html.py

Upload File

Create Folder