Changeset 69:843a49ed896c in livinglogic.python.pycoco

Show
Ignore:
Timestamp:
05/07/09 19:39:45 (10 years ago)
Author:
Walter Doerwald <walter@…>
Branch:
default
Message:

Port template to UL4.

Files:
3 modified

Legend:

Unmodified
Added
Removed
  • setup.py

    r56 r69  
    6262args = dict( 
    6363    name="pycoco", 
    64     version="0.5", 
     64    version="0.6", 
    6565    description="Python code coverage", 
    6666    long_description=descr, 
  • src/pycoco/__init__.py

    r68 r69  
    66import sys, os, datetime, urllib, optparse, contextlib 
    77 
    8 from ll import sisyphus, url 
     8from ll import sisyphus, url, ul4c 
    99 
    1010from pycoco import xmlns 
     
    160160        # Generate main page 
    161161        self.logProgress("### generating index page") 
    162         e = xmlns.page( 
    163             xmlns.filelist( 
    164                 ( 
    165                     xmlns.fileitem( 
    166                         name=file.name.split("/", 1)[-1], 
    167                         lines=len(file.lines), 
    168                         coverablelines=sum(line[0]>=0 for line in file.lines), 
    169                         coveredlines=sum(line[0]>0 for line in file.lines), 
    170                     ) 
    171                     for file in files 
    172                 ), 
    173                 timestamp=("Repository timestamp ", self.timestamp.strftime("%Y-%m-%d %H:%M:%S")), 
    174                 revision=self.revision, 
    175             ), 
    176             title=("Python code coverage (", self.timestamp.strftime("%Y-%m-%d"), ")"), 
    177             crumbs=( 
    178                 xmlns.crumb("Core Development", href="http://www.python.org/dev/", first=True), 
    179                 xmlns.crumb("Code coverage"), 
    180             ), 
    181             onload="files_prepare()", 
     162        template = ul4c.compile(xmlns.page(xmlns.filelist(), onload="files_prepare()").conv().string()) 
     163        s = template.renders( 
     164            filename=None, 
     165            now=datetime.datetime.now(), 
     166            timestamp=self.timestamp, 
     167            revision=self.revision, 
     168            crumbs=[ 
     169                dict(title="Core Development", href="http://www.python.org/dev/"), 
     170                dict(title="Code coverage", href=None), 
     171            ], 
     172            files=[ 
     173                dict( 
     174                    name=file.name.split("/", 1)[-1], 
     175                    lines=len(file.lines), 
     176                    coverablelines=sum(line[0]>=0 for line in file.lines), 
     177                    coveredlines=sum(line[0]>0 for line in file.lines), 
     178                ) for file in files 
     179            ], 
    182180        ) 
    183         e = e.conv() 
    184181        u = self.outputdir/"index.html" 
    185         e.write(u.openwrite(), base="root:index.html", encoding="utf-8") 
     182        with contextlib.closing(u.openwrite()) as f: 
     183            f.write(s.encode("utf-8")) 
    186184 
    187185        # Generate page for each source file 
     186        template = ul4c.compile(xmlns.page(xmlns.filecontent()).conv().string()) 
    188187        for (i, file) in enumerate(files): 
    189188            filename = file.name.split("/", 1)[-1] 
    190189            self.logProgress("### generating HTML %d/%d for %s" % (i+1, len(files), filename)) 
    191             e = xmlns.page( 
    192                 xmlns.filecontent(name=filename)( 
    193                     xmlns.fileline( 
    194                         content.decode("latin-1").expandtabs(8), 
    195                         lineno=i+1, 
    196                         count=count, 
    197                     ) 
    198                     for (i, (count, content)) in enumerate(file.lines) 
    199                 ), 
    200                 title=("Python code coverage: ", filename), 
    201                 crumbs=( 
    202                     xmlns.crumb("Core Development", href="http://www.python.org/dev/", first=True), 
    203                     xmlns.crumb("Code coverage", href="root:index.html"), 
    204                     xmlns.crumb(filename), 
     190            s = template.renders( 
     191                filename=filename, 
     192                crumbs=[ 
     193                    dict(title="Core Development", href="http://www.python.org/dev/"), 
     194                    dict(title="Code coverage", href="/index.html"), 
     195                    dict(title=filename, href=None), 
     196                ], 
     197                lines=( 
     198                    dict(count=count, content=content.decode("latin-1").expandtabs(8)) for (count, content) in file.lines 
    205199                ), 
    206200            ) 
    207             e = e.conv() 
    208201            u = self.outputdir/(filename + ".html") 
    209202            with contextlib.closing(u.openwrite()) as f: 
    210                 e.write(f, base="root:%s.html" % filename, encoding="utf-8") 
     203                f.write(s.encode("utf-8")) 
    211204 
    212205        # Copy CSS/JS files 
  • src/pycoco/xmlns.py

    r55 r69  
    88 
    99from ll.xist import xsc 
    10 from ll.xist.ns import xml, html, meta, htmlspecials 
     10from ll.xist.ns import xml, html, meta, htmlspecials, ul4 
    1111 
    1212 
     
    2929                html.head( 
    3030                    meta.contenttype(), 
    31                     html.title(self.attrs.title), 
    32                     meta.stylesheet(href="root:coverage.css"), 
    33                     meta.stylesheet(href="root:coverage_sortfilelist.css"), 
    34                     htmlspecials.javascript(src="root:coverage.js"), 
     31                    html.title( 
     32                        "Python code coverage", 
     33                        ul4.if_("filename"), 
     34                            ": ", ul4.printx("filename"), 
     35                        ul4.else_(), 
     36                            " (", ul4.print_("timestamp.format('%Y-%m-%d')"), ")", 
     37                        ul4.end("if"), 
     38                    ), 
     39                    meta.stylesheet(href="/coverage.css"), 
     40                    meta.stylesheet(href="/coverage_sortfilelist.css"), 
     41                    htmlspecials.javascript(src="/coverage.js"), 
    3542                ), 
    3643                html.body( 
     
    4451                        ), 
    4552                        html.div( 
    46                             self.attrs.crumbs, 
     53                            ul4.for_("(i, item) in enumerate(crumbs)"), 
     54                                html.span( 
     55                                    html.span( 
     56                                        ul4.if_("i"), 
     57                                            ">", 
     58                                        ul4.else_(), 
     59                                            u"\xbb", 
     60                                        ul4.end("if"), 
     61                                        class_="bullet", 
     62                                    ), 
     63                                    ul4.if_("item.href"), 
     64                                        html.a(ul4.printx("item.title"), href=ul4.printx("item.href")), 
     65                                    ul4.else_(), 
     66                                        html.span(ul4.printx("item.title"), class_="here"), 
     67                                    ul4.end("if"), 
     68                                ul4.end("for"), 
     69                                class_="crumb", 
     70                            ), 
    4771                            class_="crumbs", 
    4872                        ), 
     
    5377                        class_="content", 
    5478                    ), 
    55                     onload=self.attrs.onload, 
    56                 ), 
    57             ), 
    58         ) 
    59         return e.convert(converter) 
    60  
    61  
    62 class crumb(xsc.Element): 
    63     xmlns = xmlns 
    64  
    65     class Attrs(xsc.Element.Attrs): 
    66         class href(xsc.URLAttr): pass 
    67         class first(xsc.BoolAttr): pass 
    68  
    69     def convert(self, converter): 
    70         if self.attrs.first: 
    71             c = u"\xbb" 
    72         else: 
    73             c = ">" 
    74         e = self.content 
    75         if self.attrs.href: 
    76             e = html.a(e, href=self.attrs.href) 
    77         else: 
    78             e = html.span(e, class_="here") 
    79         e = html.span(html.span(c, class_="bullet"), e, class_="crumb") 
     79                    onload=ul4.attr_if("get('onload')", ul4.printx("onload")), 
     80                ), 
     81            ), 
     82        ) 
    8083        return e.convert(converter) 
    8184 
     
    9295        e = xsc.Frag( 
    9396            html.h1("Python code coverage"), 
    94             html.p("Generated at ", now.strftime("%Y-%m-%d %H:%M:%S"), class_="note"), 
    95             html.p(self.attrs.timestamp, class_="note"), 
    96             html.p(self.attrs.revision, class_="note"), 
     97            html.p("Generated at ", ul4.printx("now.format('%Y-%m-%d %H:%M:%S')"), class_="note"), 
     98            html.p("Repository timestamp ", ul4.printx("timestamp.format('%Y-%m-%d %H:%M:%S')"), class_="note"), 
     99            html.p(ul4.printx("revision"), class_="note"), 
    97100            html.p(html.a("Build log", href="buildlog.txt"), " ",html.a("Test log", href="testlog.txt"), class_="note"), 
    98101            htmlspecials.plaintable( 
     
    108111                ), 
    109112                html.tbody( 
    110                     self.content, 
     113                    ul4.for_("file in files"), 
     114                        html.tr( 
     115                            html.th( 
     116                                html.a( 
     117                                    ul4.printx("file.name"), 
     118                                    href=(ul4.printx("file.name"), ".html"), 
     119                                ), 
     120                                class_="filename", 
     121                            ), 
     122                            html.td( 
     123                                ul4.printx("file.lines"), 
     124                                class_="nroflines", 
     125                            ), 
     126                            html.td( 
     127                                ul4.printx("file.coverablelines"), 
     128                                class_="coverablelines", 
     129                            ), 
     130                            html.td( 
     131                                ul4.printx("file.coveredlines"), 
     132                                class_="coveredlines", 
     133                            ), 
     134                            html.td( 
     135                                ul4.if_("file.coverablelines"), 
     136                                    ul4.printx("((100.*file.coveredlines)/file.coverablelines).format('.2f')"), 
     137                                    "%", 
     138                                ul4.else_(), 
     139                                    "n/a", 
     140                                ul4.end("if"), 
     141                                class_=( 
     142                                    "coverage", 
     143                                    ul4.if_("not file.coverablelines"), 
     144                                        " disabled", 
     145                                    ul4.end("if"), 
     146                                ), 
     147                            ), 
     148                            html.td( 
     149                                ul4.code("totalwidth = 100"), 
     150                                ul4.if_("file.coverablelines"), 
     151                                    ul4.if_("file.coverablelines < file.lines"), 
     152                                        ul4.code("width = int(1.*(file.lines-file.coverablelines)/file.lines*100)"), 
     153                                        htmlspecials.pixel(src="/spc.gif", width=ul4.printx("width"), height=8, style="background-color: #ccc;"), 
     154                                        ul4.code("totalwidth -= width"), 
     155                                    ul4.end("if"), 
     156                                    ul4.if_("file.coveredlines < file.coverablelines"), 
     157                                        ul4.code("width = int(1.*(file.coverablelines-file.coveredlines)/file.lines*100)"), 
     158                                        htmlspecials.pixel(src="/spc.gif", width=ul4.printx("width"), height=8, style="background-color: #f00;"), 
     159                                        ul4.code("totalwidth -= width"), 
     160                                    ul4.end("if"), 
     161                                    ul4.if_("totalwidth"), 
     162                                        htmlspecials.pixel(src="/spc.gif", width=ul4.printx("totalwidth"), height=8, style="background-color: #0c0;"), 
     163                                    ul4.end("if"), 
     164                                ul4.else_(), 
     165                                    htmlspecials.pixel(src="/spc.gif", width=ul4.printx("totalwidth"), height=8, style="background-color: #000;"), 
     166                                ul4.end("if"), 
     167                                class_="dist", 
     168                            ), 
     169                            class_="files", 
     170                        ), 
     171                    ul4.end("for"), 
    111172                    id="files", 
    112173                ), 
     
    195256    def convert(self, converter): 
    196257        e = xsc.Frag( 
    197             html.h1("Python code coverage for ", self.attrs.name), 
     258            html.h1("Python code coverage for ", ul4.printx("filename")), 
    198259            htmlspecials.plaintable( 
    199260                html.thead( 
     
    205266                ), 
    206267                html.tbody( 
    207                     self.content, 
     268                    ul4.for_("(i, line) in enumerate(lines)"), 
     269                        html.tr( 
     270                            html.th(ul4.print_("i+1")), 
     271                            html.td( 
     272                                ul4.if_("not isnone(line.count) and line.count >= 0"), 
     273                                    ul4.printx("line.count"), 
     274                                ul4.else_(), 
     275                                    "n/a", 
     276                                ul4.end("if"), 
     277                                class_="count", 
     278                            ), 
     279                            html.td(ul4.printx("line.content"), class_="line"), 
     280                            class_=( 
     281                                ul4.attr_if("isnone(line.count) or line.count <= 0"), 
     282                                ul4.if_("isnone(line.count) or line.count < 0"), 
     283                                    "uncoverable", 
     284                                ul4.elif_("line.count"), 
     285                                    "uncoverable", 
     286                                ul4.end("if"), 
     287                            ), 
     288                        ), 
     289                    ul4.end("for"), 
    208290                ), 
    209291                class_="file", 
     
    211293        ) 
    212294        return e.convert(converter) 
    213  
    214  
    215 class fileline(xsc.Element): 
    216     xmlns = xmlns 
    217  
    218     class Attrs(xsc.Element.Attrs): 
    219         class lineno(xsc.IntAttr): required = True 
    220         class count(xsc.IntAttr): required = True 
    221  
    222     def convert(self, converter): 
    223         class_ = None 
    224         count = None 
    225         if self.attrs.count: 
    226             count = int(self.attrs.count) 
    227             if not count: 
    228                 class_ = "uncovered" 
    229             elif count == -1: 
    230                 class_ = "uncoverable" 
    231                 count = "n/a" 
    232         else: 
    233             class_ = "uncoverable" 
    234             count = "n/a" 
    235         e = html.tr( 
    236             html.th(self.attrs.lineno), 
    237             html.td(count, class_="count"), 
    238             html.td(self.content, class_="line"), 
    239             class_=class_ 
    240         ) 
    241         return e.convert(converter)