Changeset 3088:b8dd3543b811 in livinglogic.python.xist

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

Rename walk()s filter argument to walkfilter. Rename xfind.Selector method match() to matchpath().

Location:
src/ll/xist
Files:
3 modified

Legend:

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

    r3080 r3088  
    179179            styles = {} 
    180180            for (weight, sel, style) in iterstyles(path[-1], rules): 
    181                 if sel.match(path): 
     181                if sel.matchpath(path): 
    182182                    for prop in style.seq: 
    183183                        if not isinstance(prop, css.CSSComment): 
     
    277277        self.attributename = attributename 
    278278 
    279     def match(self, path): 
     279    def matchpath(self, path): 
    280280        if path: 
    281281            node = path[-1] 
     
    293293        self.attributevalue = attributevalue 
    294294 
    295     def match(self, path): 
     295    def matchpath(self, path): 
    296296        if path: 
    297297            node = path[-1] 
     
    310310        self.attributevalue = attributevalue 
    311311 
    312     def match(self, path): 
     312    def matchpath(self, path): 
    313313        if path: 
    314314            node = path[-1] 
     
    325325 
    326326class CSSFirstChildSelector(CSSWeightedSelector): 
    327     def match(self, path): 
     327    def matchpath(self, path): 
    328328        return len(path) >= 2 and _is_nth_node(path[-2][xsc.Element], path[-1], 1) 
    329329 
     
    333333 
    334334class CSSLastChildSelector(CSSWeightedSelector): 
    335     def match(self, path): 
     335    def matchpath(self, path): 
    336336        return len(path) >= 2 and _is_nth_last_node(path[-2][xsc.Element], path[-1], 1) 
    337337 
     
    341341 
    342342class CSSFirstOfTypeSelector(CSSWeightedSelector): 
    343     def match(self, path): 
     343    def matchpath(self, path): 
    344344        if len(path) >= 2: 
    345345            node = path[-1] 
     
    352352 
    353353class CSSLastOfTypeSelector(CSSWeightedSelector): 
    354     def match(self, path): 
     354    def matchpath(self, path): 
    355355        if len(path) >= 2: 
    356356            node = path[-1] 
     
    363363 
    364364class CSSOnlyChildSelector(CSSWeightedSelector): 
    365     def match(self, path): 
     365    def matchpath(self, path): 
    366366        if len(path) >= 2: 
    367367            node = path[-1] 
     
    378378 
    379379class CSSOnlyOfTypeSelector(CSSWeightedSelector): 
    380     def match(self, path): 
     380    def matchpath(self, path): 
    381381        if len(path) >= 2: 
    382382            node = path[-1] 
     
    393393 
    394394class CSSEmptySelector(CSSWeightedSelector): 
    395     def match(self, path): 
     395    def matchpath(self, path): 
    396396        if path: 
    397397            node = path[-1] 
     
    408408 
    409409class CSSRootSelector(CSSWeightedSelector): 
    410     def match(self, path): 
     410    def matchpath(self, path): 
    411411        return len(path) == 1 and isinstance(path[-1], xsc.Element) 
    412412 
     
    416416 
    417417class CSSLinkSelector(CSSWeightedSelector): 
    418     def match(self, path): 
     418    def matchpath(self, path): 
    419419        if path: 
    420420            node = path[-1] 
     
    427427 
    428428class CSSInvalidPseudoSelector(CSSWeightedSelector): 
    429     def match(self, path): 
     429    def matchpath(self, path): 
    430430        return False 
    431431 
     
    467467 
    468468class CSSNthChildSelector(CSSFunctionSelector): 
    469     def match(self, path): 
     469    def matchpath(self, path): 
    470470        if len(path) >= 2: 
    471471            node = path[-1] 
     
    476476 
    477477class CSSNthLastChildSelector(CSSFunctionSelector): 
    478     def match(self, path): 
     478    def matchpath(self, path): 
    479479        if len(path) >= 2: 
    480480            node = path[-1] 
     
    485485 
    486486class CSSNthOfTypeSelector(CSSFunctionSelector): 
    487     def match(self, path): 
     487    def matchpath(self, path): 
    488488        if len(path) >= 2: 
    489489            node = path[-1] 
     
    494494 
    495495class CSSNthLastOfTypeSelector(CSSFunctionSelector): 
    496     def match(self, path): 
     496    def matchpath(self, path): 
    497497        if len(path) >= 2: 
    498498            node = path[-1] 
     
    508508        self.selectors = [] # id, class, attribute etc. selectors for this node 
    509509 
    510     def match(self, path): 
     510    def matchpath(self, path): 
    511511        if path: 
    512512            node = path[-1] 
     
    514514                if self.xmlns == "*" or node.xmlns == self.xmlns: 
    515515                    for selector in self.selectors: 
    516                         if not selector.match(path): 
     516                        if not selector.matchpath(path): 
    517517                            return False 
    518518                    return True 
     
    546546    """ 
    547547 
    548     def match(self, path): 
    549         if len(path) >= 2 and self.right.match(path): 
     548    def matchpath(self, path): 
     549        if len(path) >= 2 and self.right.matchpath(path): 
    550550            # Find sibling 
    551551            node = path[-1] 
     
    556556                sibling = child 
    557557            if sibling is not None: 
    558                 return self.left.match(path[:-1]+[sibling]) 
     558                return self.left.matchpath(path[:-1]+[sibling]) 
    559559        return False 
    560560 
     
    570570    """ 
    571571 
    572     def match(self, path): 
    573         if len(path) >= 2 and self.right.match(path): 
     572    def matchpath(self, path): 
     573        if len(path) >= 2 and self.right.matchpath(path): 
    574574            node = path[-1] 
    575575            for child in path[-2][xsc.Element]: 
    576576                if child is node: # no previous element siblings 
    577577                    return False 
    578                 if self.left.match(path[:-1]+[child]): 
     578                if self.left.matchpath(path[:-1]+[child]): 
    579579                    return True 
    580580        return False 
  • src/ll/xist/xfind.py

    r3087 r3088  
    4444    Base class for all tree traversal filters that visit the complete tree. 
    4545    Whether a node gets output can be specified by overwriting the 
    46     <method>match</method> method. Selectors can be combined with various 
     46    <method>matchpath</method> method. Selectors can be combined with various 
    4747    operations (see methods below). 
    4848    """ 
    4949 
    5050    @misc.notimplemented 
    51     def match(self, path): 
     51    def matchpath(self, path): 
    5252        pass 
    5353 
    5454    def filterpath(self, path): 
    55         return (True, xsc.entercontent, xsc.enterattrs) if self.match(path) else (xsc.entercontent, xsc.enterattrs) 
     55        return (True, xsc.entercontent, xsc.enterattrs) if self.matchpath(path) else (xsc.entercontent, xsc.enterattrs) 
    5656 
    5757    def __div__(self, other): 
     
    143143        self.types = types 
    144144 
    145     def match(self, path): 
     145    def matchpath(self, path): 
    146146        if path: 
    147147            return isinstance(path[-1], self.types) 
     
    196196        self.xmlns = xsc.nsname(xmlns) 
    197197 
    198     def match(self, path): 
     198    def matchpath(self, path): 
    199199        if path: 
    200200            node = path[-1] 
     
    218218        self.xmlns = xsc.nsname(xmlns) 
    219219 
    220     def match(self, path): 
     220    def matchpath(self, path): 
    221221        if path: 
    222222            node = path[-1] 
     
    255255        self.node = node 
    256256 
    257     def match(self, path): 
     257    def matchpath(self, path): 
    258258        return path and path[-1] is self.node 
    259259 
     
    263263 
    264264class isroot(Selector): 
    265     def match(self, path): 
     265    def matchpath(self, path): 
    266266        return len(path) == 1 
    267267 
     
    295295    """ 
    296296 
    297     def match(self, path): 
     297    def matchpath(self, path): 
    298298        if path: 
    299299            node = path[-1] 
     
    329329    """ 
    330330 
    331     def match(self, path): 
     331    def matchpath(self, path): 
    332332        if len(path) >= 2: 
    333333            parent = path[-2] 
     
    364364    """ 
    365365 
    366     def match(self, path): 
     366    def matchpath(self, path): 
    367367        if len(path) >= 2: 
    368368            node = path[-1] 
     
    413413        self.attrnames = attrnames 
    414414 
    415     def match(self, path): 
     415    def matchpath(self, path): 
    416416        if path: 
    417417            node = path[-1] 
     
    435435        self.attrnames = attrnames 
    436436 
    437     def match(self, path): 
     437    def matchpath(self, path): 
    438438        if path: 
    439439            node = path[-1] 
     
    474474        self.attrvalue = attrvalue 
    475475 
    476     def match(self, path): 
     476    def matchpath(self, path): 
    477477        if path: 
    478478            node = path[-1] 
     
    497497        self.attrvalue = attrvalue 
    498498 
    499     def match(self, path): 
     499    def matchpath(self, path): 
    500500        if path: 
    501501            node = path[-1] 
     
    538538        self.attrvalue = attrvalue 
    539539 
    540     def match(self, path): 
     540    def matchpath(self, path): 
    541541        if path: 
    542542            node = path[-1] 
     
    561561        self.attrvalue = attrvalue 
    562562 
    563     def match(self, path): 
     563    def matchpath(self, path): 
    564564        if path: 
    565565            node = path[-1] 
     
    599599        self.attrvalue = attrvalue 
    600600 
    601     def match(self, path): 
     601    def matchpath(self, path): 
    602602        if path: 
    603603            node = path[-1] 
     
    622622        self.attrvalue = attrvalue 
    623623 
    624     def match(self, path): 
     624    def matchpath(self, path): 
    625625        if path: 
    626626            node = path[-1] 
     
    663663        self.attrvalue = attrvalue 
    664664 
    665     def match(self, path): 
     665    def matchpath(self, path): 
    666666        if path: 
    667667            node = path[-1] 
     
    686686        self.attrvalue = attrvalue 
    687687 
    688     def match(self, path): 
     688    def matchpath(self, path): 
    689689        if path: 
    690690            node = path[-1] 
     
    718718        self.id = id 
    719719 
    720     def match(self, path): 
     720    def matchpath(self, path): 
    721721        if path: 
    722722            node = path[-1] 
     
    757757        self.classname = classname 
    758758 
    759     def match(self, path): 
     759    def matchpath(self, path): 
    760760        if path: 
    761761            node = path[-1] 
     
    790790    </example> 
    791791    """ 
    792     def match(self, path): 
     792    def matchpath(self, path): 
    793793        return any(isinstance(node, xsc.Attr) for node in path) 
    794794 
     
    856856    </example> 
    857857    """ 
    858     def match(self, path): 
    859         if path and self.right.match(path): 
    860             return self.left.match(path[:-1]) 
     858    def matchpath(self, path): 
     859        if path and self.right.matchpath(path): 
     860            return self.left.matchpath(path[:-1]) 
    861861        return False 
    862862 
     
    889889    </example> 
    890890    """ 
    891     def match(self, path): 
    892         if path and self.right.match(path): 
     891    def matchpath(self, path): 
     892        if path and self.right.matchpath(path): 
    893893            while path: 
    894894                path = path[:-1] 
    895                 if self.left.match(path): 
     895                if self.left.matchpath(path): 
    896896                    return True 
    897897        return False 
     
    934934    """ 
    935935 
    936     def match(self, path): 
    937         if len(path) >= 2 and self.right.match(path): 
     936    def matchpath(self, path): 
     937        if len(path) >= 2 and self.right.matchpath(path): 
    938938            # Find sibling 
    939939            node = path[-1] 
     
    944944                sibling = child 
    945945            if sibling is not None: 
    946                 return self.left.match(path[:-1]+[sibling]) 
     946                return self.left.matchpath(path[:-1]+[sibling]) 
    947947        return False 
    948948 
     
    980980    """ 
    981981 
    982     def match(self, path): 
    983         if len(path) >= 2 and self.right.match(path): 
     982    def matchpath(self, path): 
     983        if len(path) >= 2 and self.right.matchpath(path): 
    984984            node = path[-1] 
    985985            for child in path[-2]: 
    986986                if child is node: # no previous siblings 
    987987                    return False 
    988                 if self.left.match(path[:-1]+[child]): 
     988                if self.left.matchpath(path[:-1]+[child]): 
    989989                    return True 
    990990        return False 
     
    10461046    """ 
    10471047 
    1048     def match(self, path): 
    1049         return any(selector.match(path) for selector in self.selectors) 
     1048    def matchpath(self, path): 
     1049        return any(selector.matchpath(path) for selector in self.selectors) 
    10501050 
    10511051    symbol = " | " 
     
    10781078    """ 
    10791079 
    1080     def match(self, path): 
    1081         return all(selector.match(path) for selector in self.selectors) 
     1080    def matchpath(self, path): 
     1081        return all(selector.matchpath(path) for selector in self.selectors) 
    10821082 
    10831083    def __and__(self, other): 
     
    11111111        self.selector = selector 
    11121112 
    1113     def match(self, path): 
    1114         return not self.selector.match(path) 
     1113    def matchpath(self, path): 
     1114        return not self.selector.matchpath(path) 
    11151115 
    11161116    def __str__(self): 
     
    11551155        self.func = func 
    11561156 
    1157     def match(self, path): 
     1157    def matchpath(self, path): 
    11581158        return self.func(path) 
    11591159 
     
    11751175        self.index = index 
    11761176 
    1177     def match(self, path): 
     1177    def matchpath(self, path): 
    11781178        if len(path) >= 2: 
    11791179            if self.index in ("even", "odd"): 
     
    12241224                yield child 
    12251225 
    1226     def match(self, path): 
     1226    def matchpath(self, path): 
    12271227        if len(path) >= 2: 
    12281228            if self.index in ("even", "odd"): 
  • src/ll/xist/xsc.py

    r3087 r3088  
    982982            stream.write(part) 
    983983 
    984     def _walk(self, filter, path): 
     984    def _walk(self, walkfilter, path): 
    985985        """ 
    986986        <par>Internal helper for <pyref method="walk"><method>walk</method></pyref>.</par> 
    987987        """ 
    988         for option in filter.filterpath(path): 
     988        for option in walkfilter.filterpath(path): 
    989989            if option is not entercontent and option is not enterattrs and option: 
    990990                yield path 
    991991 
    992     def walk(self, filter=(True, entercontent)): 
     992    def walk(self, walkfilter=(True, entercontent)): 
    993993        """ 
    994994        <par>Return an iterator for traversing the tree rooted at <self/>.</par> 
    995995 
    996         <par><arg>filter</arg> is used for specifying whether or not a node should 
    997         be yielded and when the children of this node should be traversed. If 
    998         <arg>filter</arg> is callable, it will be called for each node visited 
    999         during the traversal. A path (i.e. a list of all nodes from the root to 
    1000         the current node) will be passed to the filter on each call and the 
    1001         filter must return a sequence of <z>node handling options</z>. 
    1002         If <arg>filter</arg> is not callable, it must be a sequence of node 
     996        <par><arg>walkfilter</arg> is used for specifying whether or not a node 
     997        should be yielded and when the children of this node should be traversed. 
     998        If <arg>walkfilter</arg> is callable, it will be called for each node 
     999        visited during the traversal. A path (i.e. a list of all nodes from the 
     1000        root to the current node) will be passed to the filter on each call and 
     1001        the filter must return a sequence of <z>node handling options</z>. 
     1002        If <arg>walkfilter</arg> is not callable, it must be a sequence of node 
    10031003        handling options that will be used for all visited nodes.</par> 
    10041004 
     
    10391039        of the list being the same across calls to <method>next</method>.</par> 
    10401040        """ 
    1041         return self._walk(makewalkfilter(filter), [self]) 
    1042  
    1043     def walknode(self, filter=(True, entercontent)): 
     1041        return self._walk(makewalkfilter(walkfilter), [self]) 
     1042 
     1043    def walknode(self, walkfilter=(True, entercontent)): 
    10441044        """ 
    10451045        Return an iterator for traversing the tree. <arg>filter</arg> works the 
    1046         same as the <arg>filter</arg> argument for <pyref method="walk"><method>walk</method></pyref>. 
     1046        same as the <arg>walkfilter</arg> argument for 
     1047        <pyref method="walk"><method>walk</method></pyref>. 
    10471048        The items produced by the iterator are the nodes themselves. 
    10481049        """ 
    1049         filter = makewalkfilter(filter) 
     1050        walkfilter = makewalkfilter(walkfilter) 
    10501051        def iterate(path): 
    1051             for path in self._walk(filter, path): 
     1052            for path in self._walk(walkfilter, path): 
    10521053                yield path[-1] 
    10531054        return misc.Iterator(iterate([self])) 
    10541055 
    1055     def walkpath(self, filter=(True, entercontent)): 
    1056         """ 
    1057         Return an iterator for traversing the tree. <arg>filter</arg> works the 
    1058         same as the <arg>filter</arg> argument for <pyref method="walk"><method>walk</method></pyref>. 
    1059         The items produced by the iterator are copies of the path. 
    1060         """ 
    1061         filter = makewalkfilter(filter) 
     1056    def walkpath(self, walkfilter=(True, entercontent)): 
     1057        """ 
     1058        Return an iterator for traversing the tree. <arg>walkfilter</arg> works 
     1059        the same as the <arg>walkfilter</arg> argument for 
     1060        <pyref method="walk"><method>walk</method></pyref>. The items produced by 
     1061        the iterator are copies of the path. 
     1062        """ 
     1063        walkfilter = makewalkfilter(walkfilter) 
    10621064        def iterate(path): 
    1063             for path in self._walk(filter, path): 
     1065            for path in self._walk(walkfilter, path): 
    10641066                yield path[:] 
    10651067        return misc.Iterator(iterate([self])) 
     
    15401542                    if matcher(path): 
    15411543                        yield child 
    1542             return misc.Iterator(iterate(makewalkfilter(index).match)) 
     1544            return misc.Iterator(iterate(makewalkfilter(index).matchpath)) 
    15431545 
    15441546    def __setitem__(self, index, value): 
     
    15671569            list.__setitem__(self, index, Frag(value)) 
    15681570        else: 
    1569             matcher = makewalkfilter(index).match 
     1571            matcher = makewalkfilter(index).matchpath 
    15701572            value = Frag(value) 
    15711573            newcontent = [] 
     
    15991601            list.__delitem__(self, index) 
    16001602        else: 
    1601             matcher = makewalkfilter(index).match 
     1603            matcher = makewalkfilter(index).matchpath 
    16021604            list.__setslice__(self, 0, len(self), [child for child in self if not matcher([self, child])]) 
    16031605 
     
    20092011                warnings.warn(IllegalAttrValueWarning(self)) 
    20102012 
    2011     def _walk(self, filter, path): 
    2012         for option in filter.filterpath(path): 
     2013    def _walk(self, walkfilter, path): 
     2014        for option in walkfilter.filterpath(path): 
    20132015            if option is entercontent: 
    2014                 for result in Frag._walk(self, filter, path): 
     2016                for result in Frag._walk(self, walkfilter, path): 
    20152017                    yield result 
    20162018            elif option is enterattrs: 
     
    30663068                    if matcher(path): 
    30673069                        yield child 
    3068             return misc.Iterator(iterate(makewalkfilter(index).match)) 
     3070            return misc.Iterator(iterate(makewalkfilter(index).matchpath)) 
    30693071 
    30703072    def __setitem__(self, index, value): 
     
    30783080            self.content[index] = value 
    30793081        else: 
    3080             matcher = makewalkfilter(index).match 
     3082            matcher = makewalkfilter(index).matchpath 
    30813083            value = Frag(value) 
    30823084            newcontent = [] 
     
    31003102            del self.content[index] 
    31013103        else: 
    3102             matcher = makewalkfilter(index).match 
     3104            matcher = makewalkfilter(index).matchpath 
    31033105            self.content = Frag(child for child in self if not matcher([self, child])) 
    31043106 
     
    31403142        return self._decoratenode(node) 
    31413143 
    3142     def _walk(self, filter, path): 
    3143         for option in filter.filterpath(path): 
     3144    def _walk(self, walkfilter, path): 
     3145        for option in walkfilter.filterpath(path): 
    31443146            if option is entercontent: 
    3145                 for result in self.content._walk(filter, path): 
     3147                for result in self.content._walk(walkfilter, path): 
    31463148                    yield result 
    31473149            elif option is enterattrs: 
    3148                 for result in self.attrs._walk(filter, path): 
     3150                for result in self.attrs._walk(walkfilter, path): 
    31493151                    yield result 
    31503152            elif option: