Welcome, guest | Sign In | My Account | Store | Cart
# -*- coding: iso-8859-1 -*-
#
# Code coverage colorization:
#  - sébastien Martini <sebastien.martini@gmail.com>
#    * 5/24/2006 fixed: bug when code is completely covered (Kenneth Lind).
#
# Original recipe:
#  http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52298
#
# Original Authors:
#  - Jürgen Hermann
#  - Mike Brown <http://skew.org/~mike/>
#  - Christopher Arndt <http://chrisarndt.de>
#
import cgi
import string
import sys
import cStringIO
import os
import keyword
import token
import tokenize

_VERBOSE
= False

_KEYWORD
= token.NT_OFFSET + 1
_TEXT    
= token.NT_OFFSET + 2

_css_classes
= {
    token
.NUMBER:       'number',
    token
.OP:           'operator',
    token
.STRING:       'string',
    tokenize
.COMMENT:   'comment',
    token
.NAME:         'name',
    token
.ERRORTOKEN:   'error',
    _KEYWORD
:           'keyword',
    _TEXT
:              'text',
}

_HTML_HEADER
= """\
<!DOCTYPE HTML PUBLIC "
-//W3C//DTD HTML 4.01 Transitional//EN"
 
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>code coverage of %(title)s</title>
<meta http-equiv="Content-Type" content="text/
html; charset=iso-8859-1">

<style type="
text/css">
pre.code {
    font-style: Lucida,"
Courier New";
}
.number {
    color: #0080C0;
}
.operator {
    color: #000000;
}
.string {
    color: #008000;
}
.comment {
    color: #808080;
}
.name {
    color: #000000;
}
.error {
    color: #FF8080;
    border: solid 1.5pt #FF0000;
}
.keyword {
    color: #0000FF;
    font-weight: bold;
}
.text {
    color: #000000;
}
.notcovered {
    background-color: #FFB2B2;
}
</style>

</head>
<body>
"""


_HTML_FOOTER
= """\
</body>
</html>
"""


class Parser:
   
""" Send colored python source.
    """

   
def __init__(self, raw, out=sys.stdout, not_covered=[]):
       
""" Store the source text.
        """

       
self.raw = string.strip(string.expandtabs(raw))
       
self.out = out
       
self.not_covered = not_covered  # not covered list of lines
       
self.cover_flag = False  # is there a <span> tag opened?

   
def format(self):
       
""" Parse and send the colored source.
        """

       
# store line offsets in self.lines
       
self.lines = [0, 0]
        pos
= 0
       
while 1:
            pos
= string.find(self.raw, '\n', pos) + 1
           
if not pos: break
           
self.lines.append(pos)
       
self.lines.append(len(self.raw))

       
# parse the source and write it
       
self.pos = 0
        text
= cStringIO.StringIO(self.raw)
       
self.out.write('<pre class="code">\n')
       
try:
            tokenize
.tokenize(text.readline, self)
       
except tokenize.TokenError, ex:
            msg
= ex[0]
            line
= ex[1][0]
           
self.out.write("<h3>ERROR: %s</h3>%s\n" % (
                msg
, self.raw[self.lines[line]:]))
       
if self.cover_flag:
           
self.out.write('</span>')
           
self.cover_flag = False
       
self.out.write('\n</pre>')

   
def __call__(self, toktype, toktext, (srow,scol), (erow,ecol), line):
       
""" Token handler.
        """

       
if _VERBOSE:
           
print "type", toktype, token.tok_name[toktype], "text", toktext,
           
print "start", srow,scol, "end", erow,ecol, "<br>"

       
# calculate new positions
        oldpos
= self.pos
        newpos
= self.lines[srow] + scol
       
self.pos = newpos + len(toktext)

       
if not self.cover_flag and srow in self.not_covered:
           
self.out.write('<span class="notcovered">')
           
self.cover_flag = True

       
# handle newlines
       
if toktype in [token.NEWLINE, tokenize.NL]:
           
if self.cover_flag:
               
self.out.write('</span>')
               
self.cover_flag = False

       
# send the original whitespace, if needed
       
if newpos > oldpos:
           
self.out.write(self.raw[oldpos:newpos])

       
# skip indenting tokens
       
if toktype in [token.INDENT, token.DEDENT]:
           
self.pos = newpos
           
return

       
# map token type to a color group
       
if token.LPAR <= toktype and toktype <= token.OP:
            toktype
= token.OP
       
elif toktype == token.NAME and keyword.iskeyword(toktext):
            toktype
= _KEYWORD
        css_class
= _css_classes.get(toktype, 'text')

       
# send text
       
self.out.write('<span class="%s">' % (css_class,))
       
self.out.write(cgi.escape(toktext))
       
self.out.write('</span>')


class MissingList(list):
   
def __init__(self, i):
        list
.__init__(self, i)

   
def __contains__(self, elem):
       
for i in list.__iter__(self):
            v_
= m_ = s_ = None
           
try:
                v_
= int(i)
           
except ValueError:
                m_
, s_ = i.split('-')
           
if v_ is not None and v_ == elem:
               
return True
           
elif (m_ is not None) and (s_ is not None) and \
                     
(int(m_) <= elem) and (elem <= int(s_)):
               
return True
       
return False


def colorize_file(filename, outstream=sys.stdout, not_covered=[]):
   
"""
    Convert a python source file into colorized HTML.

    Reads file and writes to outstream (default sys.stdout).
    """

    fo
= file(filename, 'rb')
   
try:
        source
= fo.read()
   
finally:
        fo
.close()
    outstream
.write(_HTML_HEADER % {'title': os.path.basename(filename)})
   
Parser(source, out=outstream,
           not_covered
=MissingList((not_covered and \
                                    not_covered
.split(', ')) or \
                                   
[])).format()
    outstream
.write(_HTML_FOOTER)

History

  • revision 11 (13 years ago)
  • previous revisions are not available