Changeset 2548:a922ab92cbed in livinglogic.python.xist

Show
Ignore:
Timestamp:
06/02/06 19:01:58 (14 years ago)
Author:
Walter Doerwald <walter@…>
Branch:
default
Message:

Start work on ipipe-ifying the TreePresenter?.

Files:
1 modified

Legend:

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

    r2520 r2548  
    384384 
    385385 
     386class TreeLine(object): 
     387    __slots__ = ("loc", "path", "content", "node") 
     388 
     389    def __init__(self, loc, path, content, node): 
     390        self.loc = loc 
     391        self.path = path 
     392        self.content = content 
     393        self.node = node 
     394 
     395    def __iter__(self): 
     396        return iter(defaultpresenter(self.node)) 
     397 
     398    def __xattrs__(self, mode="default"): 
     399        if mode == "detail": 
     400            return ("loc", "path", "content", "node") 
     401        return ("loc", "path", "content") 
     402 
     403 
    386404class TreePresenter(Presenter): 
    387405    """ 
    388406    This presenter shows the object as a nested tree. 
    389407    """ 
    390     def __init__(self, encoding=None, showlocation=True, showpath=1): 
    391         """ 
    392         <par>Create a <class>TreePresenter</class> instance. Arguments have the 
    393         following meaning:</par> 
    394         <dlist> 
    395         <term><arg>showlocation</arg></term><item>Should the location of the 
    396         node (i.e. system id, line and column number) be displayed as the first 
    397         column? (default <lit>True</lit>).</item> 
    398         <term><arg>showpath</arg></term><item><par>This specifies if and how 
    399         the path (i.e. the position of the node in the tree) should be displayed. 
    400         Possible values are:</par> 
    401         <ulist> 
    402         <item><lit>0</lit>: Don't show a path.</item> 
    403         <item><lit>1</lit>: Show a path (e.g. as <lit>0/2/3</lit>, 
    404         i.e. this node is the 4th child of the 3rd child of the 1st child of the 
    405         root node). This is the default.</item> 
    406         <item><lit>2</lit>: Show a path as a usable Python 
    407         expression (e.g. as <lit>[0,2,3]</lit>).</item> 
    408         </ulist> 
    409         </item> 
    410         </dlist> 
    411         """ 
    412         Presenter.__init__(self, encoding) 
    413         self.showlocation = showlocation 
    414         self.showpath = showpath 
    415  
    416     def present(self, node): 
     408 
     409    def __init__(self, node, indent="\t"): 
     410        Presenter.__init__(self, node) 
     411        self.indent = indent 
     412 
     413    def __str__(self): 
     414        return "\n".join(str(line.content) for line in self) 
     415 
     416    def strindent(self, level): 
     417        indent = self.indent 
     418        if indent == "\t": 
     419            indent = "|--" 
     420        return s4tab(level*indent) 
     421 
     422    def __iter__(self): 
    417423        self._inattr = 0 
    418424        self._currentpath = [] # numerical path 
    419425        self._buffers = [] # list of [color, string] lists used for formatting attributes (this is a list, because elements may contain elements in their attributes) 
    420426 
    421         if not self.showpath and not self.showlocation: 
    422             # we need no column formatting, so we can yield the result directly 
    423             for (loc, path, line) in node.present(self): 
    424                 yield line 
    425                 yield u"\n" 
    426         else: 
    427             lines = list(node.present(self)) 
     427        for line in self.node.present(self): 
     428            yield line 
    428429     
    429             lenloc = 0 
    430             lennumpath = 0 
    431             for line in lines: 
    432                 # format and calculate width of location info 
    433                 if self.showlocation: 
    434                     loc = line[0] 
    435                     if loc is None: 
    436                         loc = xsc.Location() 
    437                     loc = str(loc) 
    438                     lenloc = max(lenloc, len(loc)) 
    439                     line[0] = loc 
    440  
    441                 # format and calculate width of path info 
    442                 if self.showpath: 
    443                     newline1 = [] 
    444                     if self.showpath == 1: 
    445                         for comp in line[1]: 
    446                             if isinstance(comp, tuple): 
    447                                 newline1.append(u"%s:%s" % (comp[0].xmlname, comp[1])) 
    448                             else: 
    449                                 newline1.append(unicode(comp)) 
    450                         line[1] = u"/".join(newline1) 
    451                     else: 
    452                         for comp in line[1]: 
    453                             if isinstance(comp, tuple): 
    454                                 newline1.append(u"(%s,%r)" % (comp[0].xmlname, comp[1])) 
    455                             else: 
    456                                 newline1.append(repr(comp)) 
    457                         line[1] = u"[%s]" % u",".join(newline1) 
    458                 lennumpath = max(lennumpath, len(line[1])) 
    459  
    460             newlines = [] 
    461             for line in lines: 
    462                 if self.showlocation: 
    463                     yield line[0] 
    464                     yield u" " * (lenloc-len(line[0])+1) # filler 
    465                 if self.showpath: 
    466                     yield line[1] 
    467                     yield u" " * (lennumpath-len(line[1])+1) # filler 
    468                 yield line[2] 
    469                 yield "\n" 
    470430        del self._inattr 
    471431        del self._buffers 
     
    495455            if i >= l-1 and tail is not None: # append tail to last line 
    496456                s = s + tail 
    497             yield [hereloc, self._currentpath[:], strtab(mynest) + s] 
     457            yield TreeLine(hereloc, self._currentpath[:], self.strindent(mynest) + s, node) 
    498458 
    499459    def strTextLineOutsideAttr(self, text): 
    500         return s4text(s4quote(u'"'), astyle.aunicode().join(EscOutlineText.parts(xsc.c4text, text)), s4quote(u'"')) 
     460        return s4text(s4quote(u'"'), text, s4quote(u'"')) 
    501461 
    502462    def strTextInAttr(self, text): 
    503         return astyle.aunicode().join(EscOutlineAttr.parts(xsc.c4attrvalue, text)) 
     463        return s4attrvalue(text) 
    504464 
    505465    def strProcInstContentLine(self, text): 
    506         return astyle.aunicode().join(EscOutlineText.parts(xsc.c4procinstcontent, text)) 
     466        return s4procinstcontent(text) 
    507467 
    508468    def strCommentTextLine(self, text): 
    509         return astyle.aunicode().join(EscOutlineText.parts(xsc.c4commenttext, text)) 
     469        return s4commenttext(text) 
    510470 
    511471    def strDocTypeTextLine(self, text): 
    512         return astyle.aunicode().join(EscOutlineText(xsc.c4doctypetext, text).parts(text)) 
     472        return s4doctypetext(text) 
    513473 
    514474    def presentFrag(self, node): 
     
    519479        else: 
    520480            if len(node): 
    521                 yield [ 
     481                yield TreeLine( 
    522482                    node.startloc, 
    523483                    self._currentpath[:], 
    524484                    s4frag( 
    525                         strtab(len(self._currentpath)), 
     485                        self.strindent(len(self._currentpath)), 
    526486                        u"<", 
    527487                        node._str(fullname=True, xml=False, decorate=False), 
    528488                        u">", 
    529                     ) 
    530                 ] 
     489                    ), 
     490                    node 
     491                ) 
    531492                self._currentpath.append(0) 
    532493                for child in node: 
     
    535496                    self._currentpath[-1] += 1 
    536497                self._currentpath.pop(-1) 
    537                 yield [ 
     498                yield TreeLine( 
    538499                    node.endloc, 
    539500                    self._currentpath[:], 
    540501                    s4frag( 
    541                         strtab(len(self._currentpath)), 
     502                        self.strindent(len(self._currentpath)), 
    542503                        u"</", 
    543504                        node._str(fullname=True, xml=False, decorate=False), 
    544505                        u">", 
    545                     ) 
    546                 ] 
     506                    ), 
     507                    node 
     508                ) 
    547509            else: 
    548                 yield [ 
     510                yield TreeLine( 
    549511                    node.startloc, 
    550512                    self._currentpath[:], 
    551513                    s4frag( 
    552                         strtab(len(self._currentpath)), 
     514                        self.strindent(len(self._currentpath)), 
    553515                        u"<", 
    554516                        node._str(fullname=True, xml=False, decorate=False), 
    555517                        u"/>", 
    556                     ) 
    557                 ] 
     518                    ), 
     519                    node 
     520                ) 
    558521 
    559522    def presentAttrs(self, node): 
    560523        if self._inattr: 
    561524            for (attrname, attrvalue) in node.iteritems(): 
    562                 self._buffers[-1] += xsc.c4attrs(" ") 
     525                self._buffers[-1] += s4attrs(" ") 
    563526                if isinstance(attrname, tuple): 
    564                     self._buffers[-1] += s4attr(xsc.c4ns(unicode(attrname[0].xmlname)), u":", s4attrname(unicode(attrname[1]))) 
     527                    self._buffers[-1] += s4attr(s4ns(unicode(attrname[0].xmlname)), u":", s4attrname(unicode(attrname[1]))) 
    565528                else: 
    566529                    self._buffers[-1] += s4attrname(unicode(attrname)) 
     
    619582            if len(node): 
    620583                self._buffers[-1] += s4element(u">") 
    621                 yield [ 
     584                yield TreeLine( 
    622585                    node.startloc, 
    623586                    self._currentpath[:], 
    624587                    s4element( 
    625                         strtab(len(self._currentpath)), 
     588                        self.strindent(len(self._currentpath)), 
    626589                        *self._buffers 
    627                     ) 
    628                 ] 
     590                    ), 
     591                    node 
     592                ) 
    629593                self._buffers = [] # we're done with the buffers for the header 
    630594                self._currentpath.append(0) 
     
    634598                    self._currentpath[-1] += 1 
    635599                self._currentpath.pop() 
    636                 yield [ 
     600                yield TreeLine( 
    637601                    node.endloc, 
    638602                    self._currentpath[:], 
    639603                    s4element( 
    640                         strtab(len(self._currentpath)), 
     604                        self.strindent(len(self._currentpath)), 
    641605                        u"</", 
    642606                        node._str(fullname=True, xml=False, decorate=False), 
    643607                        u">", 
    644                     ) 
    645                 ] 
     608                    ), 
     609                    node 
     610                ) 
    646611            else: 
    647                 self._buffers[-1] += xsc.c4element(u"/>") 
    648                 yield [ 
     612                self._buffers[-1] += s4element(u"/>") 
     613                yield TreeLine( 
    649614                    node.startloc, 
    650615                    self._currentpath[:], 
    651616                    s4element( 
    652                         strtab(len(self._currentpath)), 
     617                        self.strindent(len(self._currentpath)), 
    653618                        *self._buffers 
    654                     ) 
    655                 ] 
     619                    ), 
     620                    node 
     621                ) 
    656622                self._buffers = [] # we're done with the buffers for the header 
    657623 
    658624    def presentNull(self, node): 
    659625        if not self._inattr: 
    660             yield [ 
     626            yield TreeLine( 
    661627                node.startloc, 
    662628                self._currentpath[:], 
    663629                s4null( 
    664                     strtab(len(self._currentpath)), 
     630                    self.strindent(len(self._currentpath)), 
    665631                    node._str(fullname=True, xml=False, decorate=True) 
    666                 ) 
    667             ] 
     632                ), 
     633                node 
     634            ) 
    668635 
    669636    def presentText(self, node): 
     
    679646            self._buffers[-1].append(node._str(fullname=True, xml=False, decorate=True)) 
    680647        else: 
    681             yield [ 
     648            yield TreeLine( 
    682649                node.startloc, 
    683650                self._currentpath[:], 
    684651                s4entity( 
    685                     strtab(len(self._currentpath)), 
     652                    self.strindent(len(self._currentpath)), 
    686653                    node._str(fullname=True, xml=False, decorate=True) 
    687                 ) 
    688             ] 
     654                ), 
     655                node 
     656            ) 
    689657 
    690658    def presentProcInst(self, node): 
    691659        if self._inattr: 
    692             self._buffers[-1] += xsc.c4procinst( 
     660            self._buffers[-1] += s4procinst( 
    693661                u"<?", 
    694662                node._str(fullname=True, xml=False, decorate=False),