Changeset 3168:5cdf156ca704 in livinglogic.python.xist

Show
Ignore:
Timestamp:
01/23/08 22:08:31 (12 years ago)
Author:
Walter Doerwald <walter@…>
Branch:
default
Message:

Add a proper ReST namespace with transformation to doc. Shorten name of doc elements.

Add real text roles for :class:foo etc. Reused doc.code HTML conversion code.

Location:
src/ll/xist/ns
Files:
1 added
1 modified

Legend:

Unmodified
Added
Removed
  • src/ll/xist/ns/doc.py

    r3144 r3168  
    1515 
    1616 
    17 import sys, types, inspect, textwrap, optparse, collections, warnings, operator 
    18  
    19 try: 
    20     from docutils import nodes, utils, parsers as restparsers, frontend 
    21     from docutils.parsers.rst import roles 
    22     from docutils.parsers.rst.languages import en 
    23 except ImportError: 
    24     pass 
    25 else: 
    26     # FIXME: Do the right thing 
    27     roles.register_generic_role("mod", nodes.literal) 
    28     en.roles["mod"] = "mod" 
    29  
    30     roles.register_generic_role("class", nodes.literal) 
    31     en.roles["class"] = "class" 
    32  
    33     roles.register_generic_role("func", nodes.literal) 
    34     en.roles["func"] = "func" 
    35  
    36     roles.register_generic_role("meth", nodes.literal) 
    37     en.roles["meth"] = "meth" 
    38  
    39     roles.register_generic_role("var", nodes.literal) 
    40     en.roles["var"] = "var" 
    41  
    42     roles.register_generic_role("exc", nodes.literal) 
    43     en.roles["exc"] = "exc" 
    44  
    45     roles.register_generic_role("attr", nodes.literal) 
    46     en.roles["attr"] = "attr" 
    47  
    48     roles.register_generic_role("prop", nodes.literal) 
    49     en.roles["prop"] = "prop" 
    50  
    51     roles.register_generic_role("option", nodes.literal) 
    52     en.roles["option"] = "option" 
    53  
    54     roles.register_generic_role("const", nodes.literal) 
    55     en.roles["const"] = "const" 
    56  
    57     roles.register_generic_role("file", nodes.literal) 
    58     en.roles["file"] = "file" 
    59  
    60     roles.register_generic_role("dir", nodes.literal) 
    61     en.roles["dir"] = "dir" 
    62  
    63     roles.register_generic_role("data", nodes.literal) 
    64     en.roles["data"] = "data" 
     17from __future__ import with_statement 
     18 
     19import sys, types, inspect, textwrap, warnings, operator 
    6520 
    6621import ll 
     
    10156        return xsc.Text(text) 
    10257    elif format.lower() == "restructuredtext": 
    103         return rest2doc(text) 
     58        from ll.xist.ns import rest 
     59        return rest.fromstring(text).conv() 
    10460    elif format.lower() == "xist": 
    10561        if inspect.ismethod(thing): 
     
    210166    sig.append(u")") 
    211167    return sig 
     168 
     169 
     170class _stack(object): 
     171    def __init__(self, context, obj): 
     172        self.context = context 
     173        self.obj = obj 
     174 
     175    def __enter__(self): 
     176        self.context.stack.append(self.obj) 
     177 
     178    def __exit__(self, type, value, traceback): 
     179        self.context.stack.pop() 
    212180 
    213181 
     
    380348        def __init__(self): 
    381349            xsc.Element.Context.__init__(self) 
     350            self.stack = [] 
    382351            self.sections = [0] 
    383             self.lists = [] 
     352            self.firstheaderlevel = None 
    384353 
    385354            self.llblue = u"#006499" 
     
    454423    register = False 
    455424 
     425    def convert_html(self, converter): 
     426        e = converter.target.div(self.content) 
     427        return e.convert(converter) 
     428 
    456429 
    457430class inline(base): 
     
    461434    xmlns = xmlns 
    462435    register = False 
     436 
     437    def convert_html(self, converter): 
     438        e = converter.target.span(self.content) 
     439        return e.convert(converter) 
    463440 
    464441 
     
    471448 
    472449    def convert_docbook(self, converter): 
    473         e = converter.target.abbrev(self.content, lang=self[u"lang"]) 
     450        e = converter.target.abbrev(self.content, lang=self.attrs.lang) 
    474451        return e.convert(converter) 
    475452 
     
    502479    """ 
    503480    xmlns = xmlns 
    504     register = False 
    505481    model = sims.ElementsOrText(inline) 
    506482 
    507     cssclass = None 
     483    cssclass = "litblock" 
    508484 
    509485    def convert_html(self, converter): 
     
    687663 
    688664    def convert_html(self, converter): 
    689         e = converter.target.code(self.content, class_=u"literal") 
     665        e = converter.target.code(self.content, class_=u"lit") 
    690666        return e.convert(converter) 
    691667 
     
    702678        return e.convert(converter) 
    703679 
    704     def convert_html(self, converter): 
    705         e = converter.target.code(self.content, class_=u"function") 
    706         return e.convert(converter) 
    707  
    708680 
    709681class meth(code): 
     
    718690        return e.convert(converter) 
    719691 
    720     def convert_html(self, converter): 
    721         e = converter.target.code(self.content, class_=u"method") 
     692 
     693class attr(code): 
     694    """ 
     695    The name of an attribute of a class/object 
     696    """ 
     697    xmlns = xmlns 
     698    model = sims.ElementsOrText(rep) 
     699 
     700    def convert_docbook(self, converter): 
     701        e = converter.target.methodname(self.content) 
    722702        return e.convert(converter) 
    723703 
     
    732712    def convert_docbook(self, converter): 
    733713        e = converter.target.varname(self.content, role=u"property") 
    734         return e.convert(converter) 
    735  
    736     def convert_html(self, converter): 
    737         e = converter.target.code(self.content, class_=u"property") 
    738714        return e.convert(converter) 
    739715 
     
    749725    def convert_docbook(self, converter): 
    750726        e = converter.target.classname(self.content) 
    751         return e.convert(converter) 
    752  
    753     def convert_html(self, converter): 
    754         e = converter.target.code(self.content, class_=u"class") 
    755727        return e.convert(converter) 
    756728 
     
    826798 
    827799 
    828 class arg(code): 
     800class var(code): 
    829801    """ 
    830802    The name of a function or method argument. 
     
    837809        return e.convert(converter) 
    838810 
    839     def convert_html(self, converter): 
    840         e = converter.target.code(self.content, class_=u"arg") 
    841         return e.convert(converter) 
    842  
    843811 
    844812class mod(code): 
     
    858826 
    859827 
    860 class parameter(code): 
    861     """ 
    862     A value or a symbolic reference to a value 
     828class file(code): 
     829    """ 
     830    The name of a file 
    863831    """ 
    864832    xmlns = xmlns 
     
    866834 
    867835    def convert_docbook(self, converter): 
    868         e = converter.target.parameter(self.content) 
    869         return e.convert(converter) 
    870  
    871     def convert_html(self, converter): 
    872         e = converter.target.code(self.content, class_=u"parameter") 
    873         return e.convert(converter) 
    874  
    875  
    876 class filename(code): 
    877     """ 
    878     The name of a file 
     836        e = converter.target.filename(self.content) 
     837        return e.convert(converter) 
     838 
     839    def convert_html(self, converter): 
     840        e = converter.target.code(self.content, class_=u"filename") 
     841        return e.convert(converter) 
     842 
     843 
     844class dir(code): 
     845    """ 
     846    The name of directory 
    879847    """ 
    880848    xmlns = xmlns 
     
    882850 
    883851    def convert_docbook(self, converter): 
    884         e = converter.target.filename(self.content) 
    885         return e.convert(converter) 
    886  
    887     def convert_html(self, converter): 
    888         e = converter.target.code(self.content, class_=u"filename") 
    889         return e.convert(converter) 
    890  
    891  
    892 class dirname(code): 
    893     """ 
    894     The name of directory 
     852        e = converter.target.filename(self.content, class_=u"directory") 
     853        return e.convert(converter) 
     854 
     855 
     856class user(code): 
     857    """ 
     858    The name of a user account 
    895859    """ 
    896860    xmlns = xmlns 
     
    898862 
    899863    def convert_docbook(self, converter): 
    900         e = converter.target.filename(self.content, class_=u"directory") 
    901         return e.convert(converter) 
    902  
    903  
    904 class username(code): 
    905     """ 
    906     The name of a user account 
     864        e = converter.target.literal(self.content, role=u"username") 
     865        return e.convert(converter) 
     866 
     867 
     868class host(code): 
     869    """ 
     870    The name of a computer 
    907871    """ 
    908872    xmlns = xmlns 
     
    910874 
    911875    def convert_docbook(self, converter): 
    912         e = converter.target.literal(self.content, role=u"username") 
    913         return e.convert(converter) 
    914  
    915     def convert_html(self, converter): 
    916         e = converter.target.code(self.content, class_=u"username") 
    917         return e.convert(converter) 
    918  
    919  
    920 class hostname(code): 
    921     """ 
    922     The name of a computer 
     876        e = converter.target.literal(self.content, role=u"hostname") 
     877        return e.convert(converter) 
     878 
     879 
     880class const(code): 
     881    """ 
     882    The name of a constant 
    923883    """ 
    924884    xmlns = xmlns 
     
    926886 
    927887    def convert_docbook(self, converter): 
    928         e = converter.target.literal(self.content, role=u"hostname") 
    929         return e.convert(converter) 
    930  
    931     def convert_html(self, converter): 
    932         e = converter.target.code(self.content, class_=u"hostname") 
     888        e = converter.target.literal(self.content, role=u"constant") 
     889        return e.convert(converter) 
     890 
     891 
     892class data(code): 
     893    """ 
     894    The name of a data object 
     895    """ 
     896    xmlns = xmlns 
     897    model = sims.ElementsOrText(rep) 
     898 
     899    def convert_docbook(self, converter): 
     900        e = converter.target.literal(self.content, role=u"data") 
    933901        return e.convert(converter) 
    934902 
     
    944912 
    945913    def convert_docbook(self, converter): 
    946         e = converter.target.application(self.content, moreinfo=self[u"moreinfo"]) 
     914        e = converter.target.application(self.content, moreinfo=self.attrs.moreinfo) 
    947915        return e.convert(converter) 
    948916 
    949917    def convert_html(self, converter): 
    950918        if u"moreinfo" in self.attrs: 
    951             e = converter.target.a(self.content, class_=u"app", href=self[u"moreinfo"]) 
     919            e = converter.target.a(self.content, class_=u"app", href=self.attrs.moreinfo) 
    952920        else: 
    953921            e = converter.target.span(self.content, class_=u"app") 
     
    959927                self.content, 
    960928                converter[self].linkattrs, 
    961                 external_destination=self[u"moreinfo"] 
     929                external_destination=self.attrs.moreinfo 
    962930            ) 
    963931        else: 
     
    979947 
    980948    def convert_html(self, converter): 
    981         e = self.content 
     949        context = converter[self] 
     950        if context.stack: 
     951            if isinstance(context.stack[-1], example): 
     952                e = self.content 
     953            elif isinstance(context.stack[-1], section): 
     954                level = len(context.sections) 
     955                if context.firstheaderlevel is None: 
     956                    context.firstheaderlevel = level 
     957                e = getattr(converter.target, "h%d" % (context.firstheaderlevel+level), converter.target.h6)(self.content) 
     958            else: 
     959                raise ValueError("unknown node %r on the stack" % context.stack[-1]) 
     960        else: 
     961            context.firstheaderlevel = 0 
     962            e = converter.target.h1(self.content) 
    982963        return e.convert(converter) 
    983964 
     
    998979 
    999980    def convert_docbook(self, converter): 
    1000         e = converter.target.section(self.content, role=self[u"role"], id=self[u"id"]) 
     981        e = converter.target.section(self.content, role=self.attrs.role, id=self.attrs.id) 
    1001982        return e.convert(converter) 
    1002983 
     
    1014995            else: 
    1015996                cs.append(child) 
    1016         e = target.div(class_=(u"section level", level), id=self[u"id"]) 
    1017         if u"role" in self.attrs: 
    1018             e[u"class_"].append(u" ", self.attrs[u"role"]) 
    1019         #if u"id" in self.attrs: 
    1020         #   e.append(target.a(name=self[u"id"], id=self[u"id"])) 
     997        e = target.div(class_=(u"section level", level), id=self.attrs.id) 
     998        if "role" in self.attrs: 
     999            e.attrs.class_.append(" ", self.attrs.role) 
     1000        #if "id" in self.attrs: 
     1001        #   e.append(target.a(name=self.attrs.id, id=self.attrs.id)) 
    10211002        hclass = getattr(target, u"h%d" % level, target.h6) 
    10221003        for t in ts: 
    10231004            e.append(hclass(t.content)) 
    10241005        e.append(cs) 
    1025         # make sure to call the inner convert() before popping the number off of the stack 
    1026         e = e.convert(converter) 
    1027         del context.sections[-1] 
    1028         return e 
     1006        with _stack(context, self): 
     1007            # make sure to call the inner convert() before popping the number off of the stack 
     1008            e = e.convert(converter) 
     1009            del context.sections[-1] 
     1010            return e 
    10291011 
    10301012    def convert_fo(self, converter): 
     
    10471029                cs.append(child) 
    10481030        p = props[min(len(context.sections)-1, len(props)-1)] 
    1049         isref = unicode(self[u"role"].convert(converter)) in (u"class", u"method", u"property", u"function", u"module") 
     1031        isref = unicode(self.attrs.role.convert(converter)) in (u"class", u"method", u"property", u"function", u"module") 
    10501032 
    10511033        number = None 
     
    10931075 
    10941076    def convert_docbook(self, converter): 
    1095         e = converter.target.para(self.content, role=self[u"type"]) 
    1096         return e.convert(converter) 
    1097  
    1098     def convert_html(self, converter): 
    1099         e = converter.target.p(self.content, class_=self[u"type"]) 
     1077        e = converter.target.para(self.content, role=self.attrs.type) 
     1078        return e.convert(converter) 
     1079 
     1080    def convert_html(self, converter): 
     1081        e = converter.target.p(self.content, class_=self.attrs.type) 
    11001082        return e.convert(converter) 
    11011083 
     
    11501132 
    11511133    def convert_html(self, converter): 
    1152         context = converter[self] 
    1153         if not context.lists: 
    1154             raise xsc.NodeOutsideContextError(self, list) 
    11551134        e = converter.target.li(self.content) 
    11561135        return e.convert(converter) 
     
    12011180 
    12021181    def convert_html(self, converter): 
    1203         context = converter[self] 
    1204         if not context.lists: 
    1205             raise xsc.NodeOutsideContextError(self, list) 
    12061182        e = converter.target.dd(self.content) 
    12071183        return e.convert(converter) 
     
    12471223 
    12481224    def convert_html(self, converter): 
    1249         context = converter[self] 
    1250         context.lists.append(["ul", 0]) 
    1251         e = converter.target.ul(self.content.convert(converter)) 
    1252         del context.lists[-1] 
    1253         return e 
     1225        with _stack(converter[self], self): 
     1226            return converter.target.ul(self.content.convert(converter)) 
    12541227 
    12551228    def convert_fo(self, converter): 
     
    12741247 
    12751248    def convert_html(self, converter): 
    1276         context = converter[self] 
    1277         context.lists.append(["ol", 0]) 
    1278         e = converter.target.ol(self.content.convert(converter)) 
    1279         del context.lists[-1] 
    1280         return e 
     1249        with _stack(converter[self], self): 
     1250            return converter.target.ol(self.content.convert(converter)) 
    12811251 
    12821252    def convert_fo(self, converter): 
     
    13091279 
    13101280    def convert_html(self, converter): 
    1311         context = converter[self] 
    1312         context.lists.append(["dl", 0]) 
    1313         e = converter.target.dl(self.content.convert(converter)) 
    1314         del context.lists[-1] 
    1315         return e 
     1281        with _stack(converter[self], self): 
     1282            return converter.target.dl(self.content.convert(converter)) 
    13161283 
    13171284    def convert_fo(self, converter): 
     
    13451312        if ts: 
    13461313            e.append(target.div(ts, class_=u"example-title")) 
    1347         return e.convert(converter) 
     1314        with _stack(converter[self], self): 
     1315            return e.convert(converter) 
    13481316 
    13491317    def convert_fo(self, converter): 
     
    13671335 
    13681336    def convert_docbook(self, converter): 
    1369         e = converter.target.link(self.content, linkend=self[u"href"]) 
    1370         return e.convert(converter) 
    1371  
    1372     def convert_html(self, converter): 
    1373         e = converter.target.a(self.content, href=self[u"href"], hreflang=self[u"hreflang"]) 
     1337        e = converter.target.link(self.content, linkend=self.attrs.href) 
     1338        return e.convert(converter) 
     1339 
     1340    def convert_html(self, converter): 
     1341        e = converter.target.a(self.content, href=self.attrs.href, hreflang=self.attrs.hreflang) 
    13741342        return e.convert(converter) 
    13751343 
     
    13791347                self.content, 
    13801348                converter[self].linkattrs, 
    1381                 external_destination=self[u"href"] 
     1349                external_destination=self.attrs.href 
    13821350            ) 
    13831351        else: 
     
    13961364 
    13971365    def convert_docbook(self, converter): 
    1398         e = converter.target.link(self.content, linkend=self[u"ref"]) 
    1399         return e.convert(converter) 
    1400  
    1401     def convert_html(self, converter): 
    1402         e = converter.target.a(self.content, href=(u"#", self[u"ref"])) 
     1366        e = converter.target.link(self.content, linkend=self.attrs.ref) 
     1367        return e.convert(converter) 
     1368 
     1369    def convert_html(self, converter): 
     1370        e = converter.target.a(self.content, href=(u"#", self.attrs.ref)) 
    14031371        return e.convert(convertert) 
    14041372 
     
    14081376                self.content, 
    14091377                converter[self].linkattrs, 
    1410                 internal_destination=self[u"ref"] 
     1378                internal_destination=self.attrs.ref 
    14111379            ) 
    14121380        else: 
     
    14871455            return self.convert_doc(converter) 
    14881456        if u"function" in self.attrs: 
    1489             function = unicode(self[u"function"].convert(converter)) 
     1457            function = unicode(self.attrs.function.convert(converter)) 
    14901458        else: 
    14911459            function = None 
    14921460        if u"method" in self.attrs: 
    1493             method = unicode(self[u"method"].convert(converter)) 
     1461            method = unicode(self.attrs.method.convert(converter)) 
    14941462        else: 
    14951463            method = None 
    14961464        if u"property" in self.attrs: 
    1497             prop = unicode(self[u"property"].convert(converter)) 
     1465            prop = unicode(self.attrs.property.convert(converter)) 
    14981466        else: 
    14991467            prop = None 
    15001468        if u"class_" in self.attrs: 
    1501             class__ = unicode(self[u"class_"].convert(converter)).replace(u".", u"-") 
     1469            class__ = unicode(self.attrs.class_.convert(converter)).replace(u".", u"-") 
    15021470        else: 
    15031471            class__ = None 
    15041472        if u"module" in self.attrs: 
    1505             module = unicode(self[u"module"].convert(converter)) 
     1473            module = unicode(self.attrs.module.convert(converter)) 
    15061474            if module.startswith(u"ll."): 
    15071475                module = module[3:].replace(u".", u"/") 
     
    15961564        ) 
    15971565        return e 
    1598  
    1599  
    1600 class ReSTConversionWarning(Warning): 
    1601     pass 
    1602  
    1603  
    1604 class ReSTConverter(object): 
    1605     def __init__(self): 
    1606         self.namedrefs = collections.defaultdict() 
    1607         self.namedrefs.default_factory = list 
    1608         self.unnamedrefs = [] 
    1609  
    1610     def convert(self, node): 
    1611         if isinstance(node, nodes.document): 
    1612             return xsc.Frag(self.convert(child) for child in node.children) 
    1613         elif isinstance(node, nodes.Text): 
    1614             return xsc.Text(node.astext()) 
    1615         elif isinstance(node, nodes.problematic): 
    1616             # We don't do anything about this 
    1617             return xsc.Frag(self.convert(child) for child in node.children) 
    1618         elif isinstance(node, nodes.section): 
    1619             return section(self.convert(child) for child in node.children) 
    1620         elif isinstance(node, nodes.title): 
    1621             return h(self.convert(child) for child in node.children) 
    1622         elif isinstance(node, nodes.paragraph): 
    1623             return p(self.convert(child) for child in node.children) 
    1624         elif isinstance(node, nodes.bullet_list): 
    1625             return ul(self.convert(child) for child in node.children) 
    1626         elif isinstance(node, nodes.list_item): 
    1627             return li(self.convert(child) for child in node.children) 
    1628         elif isinstance(node, nodes.definition_list): 
    1629             return dl(self.convert(child) for child in node.children) 
    1630         elif isinstance(node, nodes.definition_list_item): 
    1631             return xsc.Frag(self.convert(child) for child in node.children) 
    1632         elif isinstance(node, nodes.term): 
    1633             return dt(self.convert(child) for child in node.children) 
    1634         elif isinstance(node, nodes.definition): 
    1635             return dd(self.convert(child) for child in node.children) 
    1636         elif isinstance(node, nodes.literal_block): 
    1637             return prog(self.convert(child) for child in node.children) 
    1638         elif isinstance(node, nodes.literal): 
    1639             return lit(self.convert(child) for child in node.children) 
    1640         elif isinstance(node, nodes.emphasis): 
    1641             return em(self.convert(child) for child in node.children) 
    1642         elif isinstance(node, nodes.substitution_reference): 
    1643             try: 
    1644                 return getattr(abbr_, node.attributes["refname"].lower())() 
    1645             except AttributeError: 
    1646                 return xsc.Frag(self.convert(child) for child in node.children) 
    1647         elif isinstance(node, nodes.reference): 
    1648             e = a(self.convert(child) for child in node.children) 
    1649             if "anonymous" in node.attributes: 
    1650                 self.unnamedrefs.append(e) 
    1651             else: 
    1652                 self.namedrefs[node.attributes["refname"]].append(e) 
    1653             return e 
    1654         elif isinstance(node, nodes.target): 
    1655             uri = node.attributes["refuri"] 
    1656             if "anonymous" in node.attributes: 
    1657                 # Set the link on the first unnamed reference 
    1658                 self.unnamedrefs[0].attrs.href = uri 
    1659                 del self.unnamedrefs[0] # done => remove it 
    1660             else: 
    1661                 for name in node.attributes["names"]: 
    1662                     try: 
    1663                         es = self.namedrefs[name] 
    1664                     except KeyError: 
    1665                         pass 
    1666                     else: 
    1667                         for e in es: 
    1668                             e.attrs.href = uri 
    1669                         del self.namedrefs[name] 
    1670             return xsc.Null 
    1671         elif isinstance(node, nodes.system_message): 
    1672             warnings.warn(ReSTConversionWarning(str(node))) 
    1673             return xsc.Null # ignore system messages 
    1674         else: 
    1675             raise TypeError("can't handle %r" % node.__class__) 
    1676  
    1677  
    1678 def rest2doc(string): 
    1679     parser = restparsers.get_parser_class("rst")() 
    1680     defaults = frontend.OptionParser().defaults.copy() 
    1681     defaults["tab_width"] = 3 
    1682     defaults["pep_references"] = 1 
    1683     defaults["pep_base_url"] = "http://www.python.org/dev/peps/" 
    1684     defaults["rfc_references"] = 1 
    1685     defaults["rfc_base_url"] = "http://www.faqs.org/rfcs/" 
    1686  
    1687     doc = utils.new_document("?", optparse.Values(defaults)) 
    1688     parser.parse(string, doc) 
    1689  
    1690     conv = ReSTConverter() 
    1691     return conv.convert(doc)