Changeset 2552:035f269bdbfb in livinglogic.python.xist

Show
Ignore:
Timestamp:
06/22/06 18:09:23 (14 years ago)
Author:
Walter Doerwald <walter@…>
Branch:
default
Message:

Finish reimplementation of TreePresenter?. When inside attribute instead
of collecting strings in buffers, the resulting astyle.Text objects are
yielded directly now. Fiddle with the colors a bit.

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • src/ll/xist/presenters.py

    r2551 r2552  
    6060 
    6161# style to be used for Null name 
    62 s4nullname = astyle.Style.fromenv("LL_XIST_STYLE_NULLNAME", "white:black:bold") 
     62s4nullname = astyle.Style.fromenv("LL_XIST_STYLE_NULLNAME", "red:black:bold") 
    6363 
    6464 
     
    6868 
    6969# style to be used for Frag name 
    70 s4fragname = astyle.Style.fromenv("LL_XIST_STYLE_FRAGNAME", "white:black:bold") 
     70s4fragname = astyle.Style.fromenv("LL_XIST_STYLE_FRAGNAME", "blue:black:bold") 
    7171 
    7272 
     
    8080 
    8181# style to be used for processing instructions 
    82 s4procinst = astyle.Style.fromenv("LL_XIST_STYLE_PROCINST", "red:black:bold") 
     82s4procinst = astyle.Style.fromenv("LL_XIST_STYLE_PROCINST", "magenta:black") 
    8383 
    8484 
    8585# style to be used for processing instruction targets 
    86 s4procinsttarget = astyle.Style.fromenv("LL_XIST_STYLE_PROCINSTTARGET", "red:black:bold") 
     86s4procinsttarget = astyle.Style.fromenv("LL_XIST_STYLE_PROCINSTTARGET", "magenta:black:bold") 
    8787 
    8888 
     
    112112 
    113113# style to be used for entity names 
    114 s4entityname = astyle.Style.fromenv("LL_XIST_STYLE_ENTITYNAME", "magenta:black") 
     114s4entityname = astyle.Style.fromenv("LL_XIST_STYLE_ENTITYNAME", "magenta:black:bold") 
    115115 
    116116 
     
    136136 
    137137# style to be used for attribute values 
    138 s4attrvalue = astyle.Style.fromenv("LL_XIST_STYLE_ATTRVALUE", "yellow:black") 
     138s4attrvalue = astyle.Style.fromenv("LL_XIST_STYLE_ATTRVALUE", "green:black") 
    139139 
    140140 
     
    407407    """ 
    408408 
     409    # When inside attributes the presenting methods yield astyle.Text objects 
     410    # Outside of attributes Line objects are yielded 
     411 
    409412    def __init__(self, node, indent=None): 
    410413        Presenter.__init__(self, node) 
     
    419422        indent = self.indent 
    420423        if indent == "\t": 
    421             indent = "   " 
     424            indent = "  " 
    422425        return s4tab(level*indent) 
    423426 
     
    428431        self._inattr = 0 
    429432        self._currentpath = [] # numerical path 
    430         self._buffers = [] # list of [color, string] lists used for formatting attributes (this is a list, because elements may contain elements in their attributes) 
    431433 
    432434        for line in self.node.present(self): 
     
    434436     
    435437        del self._inattr 
    436         del self._buffers 
    437438        del self._currentpath 
    438439 
     
    465466        if self._inattr: 
    466467            for child in node: 
    467                 for line in child.present(self): 
    468                     pass 
    469         else: 
     468                for text in child.present(self): 
     469                    yield text 
     470        else: 
     471            indent = self.strindent(len(self._currentpath)) 
     472            ns = s4ns(node.__class__.__module__) 
     473            name = s4fragname(node.__fullname__()) 
    470474            if len(node): 
    471475                yield Line( 
    472476                    node.startloc, 
    473477                    self._currentpath[:], 
    474                     s4frag( 
    475                         self.strindent(len(self._currentpath)), 
    476                         "<", 
    477                         node._str(fullname=True, xml=False, decorate=False), 
    478                         ">", 
    479                     ), 
     478                    s4frag(indent, "<", ns, ":", name, ">"), 
    480479                    node 
    481480                ) 
     
    489488                    node.endloc, 
    490489                    self._currentpath[:], 
    491                     s4frag( 
    492                         self.strindent(len(self._currentpath)), 
    493                         "</", 
    494                         node._str(fullname=True, xml=False, decorate=False), 
    495                         ">", 
    496                     ), 
     490                    s4frag(indent, "</", ns, ":", name, ">"), 
    497491                    node 
    498492                ) 
     
    501495                    node.startloc, 
    502496                    self._currentpath[:], 
    503                     s4frag( 
    504                         self.strindent(len(self._currentpath)), 
    505                         "<", 
    506                         node._str(fullname=True, xml=False, decorate=False), 
    507                         "/>", 
    508                     ), 
     497                    s4frag(indent, "<", ns, ":", name, "/>"), 
    509498                    node 
    510499                ) 
     
    513502        if self._inattr: 
    514503            for (attrname, attrvalue) in node.iteritems(): 
    515                 self._buffers[-1] += s4attrs(" ") 
     504                yield " " 
    516505                if isinstance(attrname, tuple): 
    517                     self._buffers[-1] += s4attr(s4ns(self.text(unicode(attrname[0].xmlname))), ":", s4attrname(self.text(unicode(attrname[1])))) 
     506                    yield s4attr(s4ns(self.text(unicode(attrname[0].xmlname))), ":", s4attrname(self.text(unicode(attrname[1])))) 
    518507                else: 
    519                     self._buffers[-1] += s4attrname(self.text(unicode(attrname))) 
    520                 self._buffers[-1] += s4attr('="') 
    521                 for line in attrvalue.present(self): 
    522                     pass 
    523                 self._buffers[-1] += s4attr('"') 
    524         else: 
     508                    yield s4attrname(self.text(unicode(attrname))) 
     509                yield s4attr('="') 
     510                for text in attrvalue.present(self): 
     511                    yield text 
     512                yield s4attr('"') 
     513        else: 
     514            indent = self.strindent(len(self._currentpath)) 
     515            ns = s4ns(node.__class__.__module__) 
     516            name = s4attrsname(node.__fullname__()) 
    525517            yield Line( 
    526518                node.startloc, 
    527519                self._currentpath[:], 
    528                 s4attrs( 
    529                     strtab(len(self._currentpath)), 
    530                     "<", 
    531                     node._str(fullname=True, xml=False, decorate=False), 
    532                     ">", 
    533                 ), 
     520                s4attrs(indent, "<", ns, ":", name, ">"), 
    534521                node 
    535522            ) 
     
    543530                node.endloc, 
    544531                self._currentpath[:], 
    545                 s4attrs( 
    546                     strtab(len(self._currentpath)), 
    547                     "</", 
    548                     node._str(fullname=True, xml=False, decorate=False), 
    549                     ">", 
    550                 ), 
     532                s4attrs(indent, "</", ns, ":", name, ">"), 
    551533                node 
    552534            ) 
    553535 
    554536    def presentElement(self, node): 
    555         if self._inattr: 
    556             self._buffers[-1] += s4element(u"<", node._str(fullname=True, xml=False, decorate=False)) 
     537        ns = s4ns(node.__class__.__module__) 
     538        name = s4elementname(node.__fullname__()) 
     539        if self._inattr: 
     540            yield s4element("<", ns, ":", name) 
     541            self._inattr += 1 
     542            for text in node.attrs.present(self): 
     543                yield text 
     544            self._inattr -= 1 
     545            if len(node): 
     546                yield s4element(">") 
     547                for text in node.content.present(self): 
     548                    yield text 
     549                yield s4element("</", ns, ":", name, ">") 
     550            else: 
     551                yield s4element("/>") 
     552        else: 
     553            firstline = s4element("<", ns, ":", name) 
     554            indent = self.strindent(len(self._currentpath)) 
     555 
    557556            self._inattr += 1 
    558557            for line in node.attrs.present(self): 
    559                 pass 
     558                firstline.append(line) 
    560559            self._inattr -= 1 
    561560            if len(node): 
    562                 self._buffers[-1] += s4element(">") 
    563                 for line in node.content.present(self): 
    564                     pass 
    565                 self._buffers[-1] += s4element("</", node._str(fullname=True, xml=False, decorate=False), ">") 
    566             else: 
    567                 self._buffers[-1] += s4element("/>") 
    568         else: 
    569             self._buffers.append(s4element(u"<", node._str(fullname=True, xml=False, decorate=False))) 
    570             self._inattr += 1 
    571             for line in node.attrs.present(self): 
    572                 yield line 
    573             self._inattr -= 1 
    574             if len(node): 
    575                 self._buffers[-1] += s4element(u">") 
     561                firstline.append(">") 
    576562                yield Line( 
    577563                    node.startloc, 
    578564                    self._currentpath[:], 
    579                     s4element( 
    580                         self.strindent(len(self._currentpath)), 
    581                         *self._buffers 
    582                     ), 
     565                    indent + firstline, 
    583566                    node 
    584567                ) 
    585                 self._buffers = [] # we're done with the buffers for the header 
    586568                self._currentpath.append(0) 
    587569                for child in node: 
     
    593575                    node.endloc, 
    594576                    self._currentpath[:], 
    595                     s4element( 
    596                         self.strindent(len(self._currentpath)), 
    597                         "</", 
    598                         node._str(fullname=True, xml=False, decorate=False), 
    599                         ">", 
    600                     ), 
     577                    s4element(indent, "</", ns, ":", name, ">"), 
    601578                    node 
    602579                ) 
    603580            else: 
    604                 self._buffers[-1] += s4element(u"/>") 
     581                firstline.append("/>") 
    605582                yield Line( 
    606583                    node.startloc, 
    607584                    self._currentpath[:], 
    608                     s4element( 
    609                         self.strindent(len(self._currentpath)), 
    610                         *self._buffers 
    611                     ), 
     585                    indent + firstline, 
    612586                    node 
    613587                ) 
    614                 self._buffers = [] # we're done with the buffers for the header 
    615588 
    616589    def presentNull(self, node): 
    617590        if not self._inattr: 
     591            indent = self.strindent(len(self._currentpath)) 
     592            ns = s4ns(node.__class__.__module__) 
     593            name = s4nullname(node.__fullname__()) 
    618594            yield Line( 
    619595                node.startloc, 
    620596                self._currentpath[:], 
    621                 s4null( 
    622                     self.strindent(len(self._currentpath)), 
    623                     node._str(fullname=True, xml=False, decorate=True) 
    624                 ), 
     597                s4null(indent, "<", ns, ":", name, "/>"), 
    625598                node 
    626599            ) 
     
    628601    def presentText(self, node): 
    629602        if self._inattr: 
    630             self._buffers[-1] += s4attrvalue(self.text(node.content)) 
     603            yield s4attrvalue(self.text(node.content)) 
    631604        else: 
    632605            lines = node.content.splitlines(True) 
     
    635608 
    636609    def presentEntity(self, node): 
    637         if self._inattr: 
    638             self._buffers[-1].append(node._str(fullname=True, xml=False, decorate=True)) 
    639         else: 
     610        ns = s4ns(node.__class__.__module__) 
     611        name = s4entityname(node.__fullname__()) 
     612        if self._inattr: 
     613            yield s4entity("&", ns, ":", name, ";") 
     614        else: 
     615            indent = self.strindent(len(self._currentpath)) 
    640616            yield Line( 
    641617                node.startloc, 
    642618                self._currentpath[:], 
    643                 s4entity( 
    644                     self.strindent(len(self._currentpath)), 
    645                     node._str(fullname=True, xml=False, decorate=True) 
    646                 ), 
     619                s4entity(indent, "&", ns, ":", name, ";"), 
    647620                node 
    648621            ) 
    649622 
    650623    def presentProcInst(self, node): 
    651         if self._inattr: 
    652             self._buffers[-1] += s4procinst( 
    653                 "<?", 
    654                 node._str(fullname=True, xml=False, decorate=False), 
    655                 " ", 
    656                 color4procinstcontent(self.text(node.content)), 
    657                 "?>", 
    658             ) 
    659         else: 
    660             head = s4procinst(u"<?", node._str(fullname=True, xml=False, decorate=False), u" ") 
    661             tail = s4procinst(u"?>") 
     624        ns = s4ns(node.__class__.__module__) 
     625        name = s4procinsttarget(node.__fullname__()) 
     626        if self._inattr: 
     627            yield s4procinst("<?", ns, ":", name, " ", s4procinstcontent(self.text(node.content)), "?>") 
     628        else: 
     629            head = s4procinst("<?", ns, ":", name, " ") 
     630            tail = s4procinst("?>") 
    662631            lines = node.content.splitlines() 
    663632            if len(lines)>1: 
    664                 lines.insert(0, u"") 
     633                lines.insert(0, "") 
    665634            for line in self._domultiline(node, lines, 1, s4procinstcontent, head, tail): 
    666635                yield line 
     
    668637    def presentComment(self, node): 
    669638        if self._inattr: 
    670             self._buffers[-1] += s4comment( 
    671                 "<!--", 
    672                 self.text(node.content), 
    673                 "-->", 
    674             ) 
    675         else: 
    676             head = s4comment(u"<!--") 
    677             tail = s4comment(u"-->") 
     639            yield s4comment("<!--", s4commenttext(self.text(node.content)), "-->") 
     640        else: 
     641            head = s4comment("<!--") 
     642            tail = s4comment("-->") 
    678643            lines = node.content.splitlines() 
    679644            for line in self._domultiline(node, lines, 1, s4commenttext, head, tail): 
     
    682647    def presentDocType(self, node): 
    683648        if self._inattr: 
    684             self._buffers[-1] += s4doctype( 
    685                 "<!DOCTYPE ", 
    686                 s4doctypetext(self.text(node.content)), 
    687                 ">", 
    688             ) 
    689         else: 
    690             head = s4doctype(u"<!DOCTYPE ") 
    691             tail = s4doctype(u">") 
     649            yield s4doctype("<!DOCTYPE ", s4doctypetext(self.text(node.content)), ">") 
     650        else: 
     651            head = s4doctype("<!DOCTYPE ") 
     652            tail = s4doctype(">") 
    692653            lines = node.content.splitlines() 
    693654            for line in self._domultiline(node, lines, 1, s4doctypetext, head, tail): 
     
    697658        if self._inattr: 
    698659            # this will not be popped at the and of this method, because presentElement needs it 
    699             self._buffers.append(s4attrvalue()) 
     660            # self._buffers.append(s4attrvalue()) 
     661            pass 
    700662        for line in self.presentFrag(node): 
    701663            yield line