Mercurial > genshi > mirror

annotate markup/path.py @ 85:4938c310d904 trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Improve handling of DOCTYPE declarations.
author cmlenz
date Sun, 16 Jul 2006 11:07:34 +0000
parents f5ec6d4a61e4
children f9473bdc93b2
rev   line source
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
1 # -*- coding: utf-8 -*-
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
2 #
66
59eb24184e9c Switch copyright to Edgewall and URLs to markup.edgewall.org.
cmlenz
parents: 61
diff changeset
3 # Copyright (C) 2006 Edgewall Software
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
4 # All rights reserved.
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
5 #
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
6 # This software is licensed as described in the file COPYING, which
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
7 # you should have received as part of this distribution. The terms
66
59eb24184e9c Switch copyright to Edgewall and URLs to markup.edgewall.org.
cmlenz
parents: 61
diff changeset
8 # are also available at http://markup.edgewall.org/wiki/License.
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
9 #
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
10 # This software consists of voluntary contributions made by many
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
11 # individuals. For the exact contribution history, see the revision
66
59eb24184e9c Switch copyright to Edgewall and URLs to markup.edgewall.org.
cmlenz
parents: 61
diff changeset
12 # history and logs, available at http://markup.edgewall.org/log/.
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
13
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
14 """Basic support for evaluating XPath expressions against streams."""
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
15
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
16 import re
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
17
70
dd73921530e8 Use `collections.deque` for the template context stack on Python 2.4, which improves performance if there are many context frame pop/push operations.
cmlenz
parents: 69
diff changeset
18 from markup.core import QName, Stream, START, END, TEXT
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
19
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
20 __all__ = ['Path']
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
21
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
22
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
23 class Path(object):
26
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
24 """Implements basic XPath support on streams.
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
25
26
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
26 Instances of this class represent a "compiled" XPath expression, and provide
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
27 methods for testing the path against a stream, as well as extracting a
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
28 substream matching that path.
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
29 """
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
30 _TOKEN_RE = re.compile('(::|\.\.|\(\)|[/.:\[\]\(\)@=!])|'
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
31 '([^/:\[\]\(\)@=!\s]+)|'
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
32 '\s+')
26
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
33 _QUOTES = (("'", "'"), ('"', '"'))
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
34
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
35 def __init__(self, text):
26
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
36 """Create the path object from a string.
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
37
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
38 @param text: the path expression
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
39 """
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
40 self.source = text
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
41
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
42 steps = []
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
43 cur_op = ''
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
44 cur_tag = ''
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
45 in_predicate = False
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
46 for op, tag in self._TOKEN_RE.findall(text):
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
47 if op:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
48 if op == '[':
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
49 in_predicate = True
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
50 elif op == ']':
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
51 in_predicate = False
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
52 elif op.startswith('('):
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
53 if cur_tag == 'text':
77
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
54 steps[-1] = (False, self._function_text(), [])
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
55 else:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
56 raise NotImplementedError('XPath function "%s" not '
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
57 'supported' % cur_tag)
38
ee669cb9cccc Fix for #2 (incorrect context node in path expressions). Still some paths that produce incorrect results, but the common case seems to work now.
cmlenz
parents: 37
diff changeset
58 elif op == '.':
77
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
59 steps.append([False, self._node_test_current_element(), []])
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
60 else:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
61 cur_op += op
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
62 cur_tag = ''
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
63 else:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
64 closure = cur_op in ('', '//')
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
65 if cur_op == '@':
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
66 if tag == '*':
77
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
67 node_test = self._node_test_any_attribute()
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
68 else:
77
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
69 node_test = self._node_test_attribute_by_name(tag)
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
70 else:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
71 if tag == '*':
77
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
72 node_test = self._node_test_any_child_element()
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
73 elif in_predicate:
26
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
74 if len(tag) > 1 and (tag[0], tag[-1]) in self._QUOTES:
77
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
75 node_test = self._literal_string(tag[1:-1])
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
76 if cur_op == '=':
77
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
77 node_test = self._operator_eq(steps[-1][2][-1],
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
78 node_test)
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
79 steps[-1][2].pop()
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
80 elif cur_op == '!=':
77
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
81 node_test = self._operator_neq(steps[-1][2][-1],
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
82 node_test)
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
83 steps[-1][2].pop()
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
84 else:
77
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
85 node_test = self._node_test_child_element_by_name(tag)
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
86 if in_predicate:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
87 steps[-1][2].append(node_test)
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
88 else:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
89 steps.append([closure, node_test, []])
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
90 cur_op = ''
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
91 cur_tag = tag
38
ee669cb9cccc Fix for #2 (incorrect context node in path expressions). Still some paths that produce incorrect results, but the common case seems to work now.
cmlenz
parents: 37
diff changeset
92
ee669cb9cccc Fix for #2 (incorrect context node in path expressions). Still some paths that produce incorrect results, but the common case seems to work now.
cmlenz
parents: 37
diff changeset
93 self.steps = []
ee669cb9cccc Fix for #2 (incorrect context node in path expressions). Still some paths that produce incorrect results, but the common case seems to work now.
cmlenz
parents: 37
diff changeset
94 for step in steps:
ee669cb9cccc Fix for #2 (incorrect context node in path expressions). Still some paths that produce incorrect results, but the common case seems to work now.
cmlenz
parents: 37
diff changeset
95 self.steps.append(tuple(step))
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
96
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
97 def __repr__(self):
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
98 return '<%s "%s">' % (self.__class__.__name__, self.source)
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
99
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
100 def select(self, stream):
26
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
101 """Returns a substream of the given stream that matches the path.
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
102
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
103 If there are no matches, this method returns an empty stream.
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
104
33
1fdb7054fb42 Add doctests for path module.
cmlenz
parents: 27
diff changeset
105 >>> from markup.input import XML
1fdb7054fb42 Add doctests for path module.
cmlenz
parents: 27
diff changeset
106 >>> xml = XML('<root><elem><child>Text</child></elem></root>')
61
448792ab1303 Use a different namespace than Kid uses.
cmlenz
parents: 38
diff changeset
107
33
1fdb7054fb42 Add doctests for path module.
cmlenz
parents: 27
diff changeset
108 >>> print Path('child').select(xml)
1fdb7054fb42 Add doctests for path module.
cmlenz
parents: 27
diff changeset
109 <child>Text</child>
1fdb7054fb42 Add doctests for path module.
cmlenz
parents: 27
diff changeset
110
1fdb7054fb42 Add doctests for path module.
cmlenz
parents: 27
diff changeset
111 >>> print Path('child/text()').select(xml)
1fdb7054fb42 Add doctests for path module.
cmlenz
parents: 27
diff changeset
112 Text
1fdb7054fb42 Add doctests for path module.
cmlenz
parents: 27
diff changeset
113
26
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
114 @param stream: the stream to select from
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
115 @return: the substream matching the path, or an empty stream
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
116 """
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
117 stream = iter(stream)
26
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
118 def _generate():
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
119 test = self.test()
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
120 for kind, data, pos in stream:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
121 result = test(kind, data, pos)
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
122 if result is True:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
123 yield kind, data, pos
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
124 depth = 1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
125 while depth > 0:
73
1da51d718391 Some more performance tweaks.
cmlenz
parents: 70
diff changeset
126 subkind, subdata, subpos = stream.next()
1da51d718391 Some more performance tweaks.
cmlenz
parents: 70
diff changeset
127 if subkind is START:
1da51d718391 Some more performance tweaks.
cmlenz
parents: 70
diff changeset
128 depth += 1
1da51d718391 Some more performance tweaks.
cmlenz
parents: 70
diff changeset
129 elif subkind is END:
1da51d718391 Some more performance tweaks.
cmlenz
parents: 70
diff changeset
130 depth -= 1
1da51d718391 Some more performance tweaks.
cmlenz
parents: 70
diff changeset
131 yield subkind, subdata, subpos
1da51d718391 Some more performance tweaks.
cmlenz
parents: 70
diff changeset
132 test(subkind, subdata, subpos)
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
133 elif result:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
134 yield result
26
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
135 return Stream(_generate())
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
136
38
ee669cb9cccc Fix for #2 (incorrect context node in path expressions). Still some paths that produce incorrect results, but the common case seems to work now.
cmlenz
parents: 37
diff changeset
137 def test(self, ignore_context=False):
26
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
138 """Returns a function that can be used to track whether the path matches
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
139 a specific stream event.
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
140
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
141 The function returned expects the positional arguments `kind`, `data`,
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
142 and `pos`, i.e. basically an unpacked stream event. If the path matches
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
143 the event, the function returns the match (for example, a `START` or
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
144 `TEXT` event.) Otherwise, it returns `None` or `False`.
33
1fdb7054fb42 Add doctests for path module.
cmlenz
parents: 27
diff changeset
145
1fdb7054fb42 Add doctests for path module.
cmlenz
parents: 27
diff changeset
146 >>> from markup.input import XML
1fdb7054fb42 Add doctests for path module.
cmlenz
parents: 27
diff changeset
147 >>> xml = XML('<root><elem><child id="1"/></elem><child id="2"/></root>')
1fdb7054fb42 Add doctests for path module.
cmlenz
parents: 27
diff changeset
148 >>> test = Path('child').test()
1fdb7054fb42 Add doctests for path module.
cmlenz
parents: 27
diff changeset
149 >>> for kind, data, pos in xml:
1fdb7054fb42 Add doctests for path module.
cmlenz
parents: 27
diff changeset
150 ... if test(kind, data, pos):
1fdb7054fb42 Add doctests for path module.
cmlenz
parents: 27
diff changeset
151 ... print kind, data
1fdb7054fb42 Add doctests for path module.
cmlenz
parents: 27
diff changeset
152 START (u'child', [(u'id', u'1')])
1fdb7054fb42 Add doctests for path module.
cmlenz
parents: 27
diff changeset
153 START (u'child', [(u'id', u'2')])
26
3c1a022be04c * Split out the XPath tests into a separate `unittest`-based file.
cmlenz
parents: 25
diff changeset
154 """
69
c40a5dcd2b55 A couple of minor performance improvements.
cmlenz
parents: 66
diff changeset
155 from markup.core import END, START
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
156 stack = [0] # stack of cursors into the location path
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
157
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
158 def _test(kind, data, pos):
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
159 if not stack:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
160 return False
77
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
161 cursor = stack[-1]
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
162
77
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
163 if kind is END:
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
164 stack.pop()
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
165 return None
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
166
69
c40a5dcd2b55 A couple of minor performance improvements.
cmlenz
parents: 66
diff changeset
167 elif kind is START:
77
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
168 stack.append(cursor)
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
169
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
170 matched = False
77
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
171 closure, node_test, predicates = self.steps[cursor]
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
172
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
173 matched = node_test(kind, data, pos)
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
174 if matched and predicates:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
175 for predicate in predicates:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
176 if not predicate(kind, data, pos):
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
177 matched = None
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
178 break
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
179
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
180 if matched:
77
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
181 if cursor == len(self.steps) - 1:
38
ee669cb9cccc Fix for #2 (incorrect context node in path expressions). Still some paths that produce incorrect results, but the common case seems to work now.
cmlenz
parents: 37
diff changeset
182 if ignore_context or len(stack) > 2 \
ee669cb9cccc Fix for #2 (incorrect context node in path expressions). Still some paths that produce incorrect results, but the common case seems to work now.
cmlenz
parents: 37
diff changeset
183 or node_test.axis != 'child':
ee669cb9cccc Fix for #2 (incorrect context node in path expressions). Still some paths that produce incorrect results, but the common case seems to work now.
cmlenz
parents: 37
diff changeset
184 return matched
ee669cb9cccc Fix for #2 (incorrect context node in path expressions). Still some paths that produce incorrect results, but the common case seems to work now.
cmlenz
parents: 37
diff changeset
185 else:
ee669cb9cccc Fix for #2 (incorrect context node in path expressions). Still some paths that produce incorrect results, but the common case seems to work now.
cmlenz
parents: 37
diff changeset
186 stack[-1] += 1
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
187
69
c40a5dcd2b55 A couple of minor performance improvements.
cmlenz
parents: 66
diff changeset
188 elif kind is START and not closure:
24
5a4d45703319 Cosmetic (mostly whitespace) changes.
cmlenz
parents: 23
diff changeset
189 # If this step is not a closure, it cannot be matched until the
5a4d45703319 Cosmetic (mostly whitespace) changes.
cmlenz
parents: 23
diff changeset
190 # current element is closed... so we need to move the cursor
5a4d45703319 Cosmetic (mostly whitespace) changes.
cmlenz
parents: 23
diff changeset
191 # back to the last closure and retest that against the current
5a4d45703319 Cosmetic (mostly whitespace) changes.
cmlenz
parents: 23
diff changeset
192 # element
77
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
193 closures = [step for step in self.steps[:cursor] if step[0]]
25
e3be27f5bcf5 Oops. Fix typo in [25].
cmlenz
parents: 24
diff changeset
194 closures.reverse()
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
195 for closure, node_test, predicates in closures:
77
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
196 cursor -= 1
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
197 if closure:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
198 matched = node_test(kind, data, pos)
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
199 if matched:
77
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
200 cursor += 1
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
201 break
77
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
202 stack[-1] = cursor
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
203
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
204 return None
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
205
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
206 return _test
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
207
77
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
208 def _node_test_current_element(self):
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
209 def _test(kind, *_):
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
210 return kind is START
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
211 _test.axis = 'self'
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
212 return _test
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
213
77
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
214 def _node_test_any_child_element(self):
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
215 def _test(kind, *_):
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
216 return kind is START
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
217 _test.axis = 'child'
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
218 return _test
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
219
77
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
220 def _node_test_child_element_by_name(self, name):
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
221 def _test(kind, data, _):
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
222 return kind is START and data[0].localname == name
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
223 _test.axis = 'child'
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
224 return _test
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
225
77
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
226 def _node_test_any_attribute(self):
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
227 def _test(kind, data, _):
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
228 if kind is START and data[1]:
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
229 return data[1]
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
230 _test.axis = 'attribute'
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
231 return _test
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
232
77
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
233 def _node_test_attribute_by_name(self, name):
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
234 def _test(kind, data, pos):
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
235 if kind is START and name in data[1]:
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
236 return TEXT, data[1].get(name), pos
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
237 _test.axis = 'attribute'
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
238 return _test
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
239
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
240 def _function_text(self):
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
241 def _test(kind, data, pos):
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
242 return kind is TEXT and (kind, data, pos)
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
243 _test.axis = None
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
244 return _test
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
245
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
246 def _literal_string(self, text):
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
247 def _test(*_):
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
248 return TEXT, text, (None, -1, -1)
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
249 _test.axis = None
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
250 return _test
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
251
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
252 def _operator_eq(self, lval, rval):
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
253 def _test(kind, data, pos):
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
254 lv = lval(kind, data, pos)
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
255 rv = rval(kind, data, pos)
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
256 return (lv and lv[1]) == (rv and rv[1])
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
257 _test.axis = None
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
258 return _test
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
259
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
260 def _operator_neq(self, lval, rval):
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
261 def _test(kind, data, pos):
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
262 lv = lval(kind, data, pos)
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
263 rv = rval(kind, data, pos)
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
264 return (lv and lv[1]) != (rv and rv[1])
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
265 _test.axis = None
f5ec6d4a61e4 * Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents: 73
diff changeset
266 return _test
Copyright (C) 2012-2017 Edgewall Software