1 require 'rexml/functions'
2 require 'rexml/xmltokens'
3
4 module REXML
5 class QuickPath
6 include Functions
7 include XMLTokens
8
9 EMPTY_HASH = {}
10
11 def QuickPath::first element, path, namespaces=EMPTY_HASH
12 match(element, path, namespaces)[0]
13 end
14
15 def QuickPath::each element, path, namespaces=EMPTY_HASH, &block
16 path = "*" unless path
17 match(element, path, namespaces).each( &block )
18 end
19
20 def QuickPath::match element, path, namespaces=EMPTY_HASH
21 raise "nil is not a valid xpath" unless path
22 results = nil
23 Functions::namespace_context = namespaces
24 case path
25 when /^\/([^\/]|$)/u
26 # match on root
27 path = path[1..-1]
28 return [element.root.parent] if path == ''
29 results = filter([element.root], path)
30 when /^[-\w]*::/u
31 results = filter([element], path)
32 when /^\*/u
33 results = filter(element.to_a, path)
34 when /^[\[!\w:]/u
35 # match on child
36 matches = []
37 children = element.to_a
38 results = filter(children, path)
39 else
40 results = filter([element], path)
41 end
42 return results
43 end
44
45 # Given an array of nodes it filters the array based on the path. The
46 # result is that when this method returns, the array will contain elements
47 # which match the path
48 def QuickPath::filter elements, path
49 return elements if path.nil? or path == '' or elements.size == 0
50 case path
51 when /^\/\//u # Descendant
52 return axe( elements, "descendant-or-self", $' )
53 when /^\/?\b(\w[-\w]*)\b::/u # Axe
54 axe_name = $1
55 rest = $'
56 return axe( elements, $1, $' )
57 when /^\/(?=\b([:!\w][-\.\w]*:)?[-!\*\.\w]*\b([^:(]|$)|\*)/u # Child
58 rest = $'
59 results = []
60 elements.each do |element|
61 results |= filter( element.to_a, rest )
62 end
63 return results
64 when /^\/?(\w[-\w]*)\(/u # / Function
65 return function( elements, $1, $' )
66 when Namespace::NAMESPLIT # Element name
67 name = $2
68 ns = $1
69 rest = $'
70 elements.delete_if do |element|
71 !(element.kind_of? Element and
72 (element.expanded_name == name or
73 (element.name == name and
74 element.namespace == Functions.namespace_context[ns])))
75 end
76 return filter( elements, rest )
77 when /^\/\[/u
78 matches = []
79 elements.each do |element|
80 matches |= predicate( element.to_a, path[1..-1] ) if element.kind_of? Element
81 end
82 return matches
83 when /^\[/u # Predicate
84 return predicate( elements, path )
85 when /^\/?\.\.\./u # Ancestor
86 return axe( elements, "ancestor", $' )
87 when /^\/?\.\./u # Parent
88 return filter( elements.collect{|e|e.parent}, $' )
89 when /^\/?\./u # Self
90 return filter( elements, $' )
91 when /^\*/u # Any
92 results = []
93 elements.each do |element|
94 results |= filter( [element], $' ) if element.kind_of? Element
95 #if element.kind_of? Element
96 # children = element.to_a
97 # children.delete_if { |child| !child.kind_of?(Element) }
98 # results |= filter( children, $' )
99 #end
100 end
101 return results
102 end
103 return []
104 end
105
106 def QuickPath::axe( elements, axe_name, rest )
107 matches = []
108 matches = filter( elements.dup, rest ) if axe_name =~ /-or-self$/u
109 case axe_name
110 when /^descendant/u
111 elements.each do |element|
112 matches |= filter( element.to_a, "descendant-or-self::#{rest}" ) if element.kind_of? Element
113 end
114 when /^ancestor/u
115 elements.each do |element|
116 while element.parent
117 matches << element.parent
118 element = element.parent
119 end
120 end
121 matches = filter( matches, rest )
122 when "self"
123 matches = filter( elements, rest )
124 when "child"
125 elements.each do |element|
126 matches |= filter( element.to_a, rest ) if element.kind_of? Element
127 end
128 when "attribute"
129 elements.each do |element|
130 matches << element.attributes[ rest ] if element.kind_of? Element
131 end
132 when "parent"
133 matches = filter(elements.collect{|element| element.parent}.uniq, rest)
134 when "following-sibling"
135 matches = filter(elements.collect{|element| element.next_sibling}.uniq,
136 rest)
137 when "previous-sibling"
138 matches = filter(elements.collect{|element|
139 element.previous_sibling}.uniq, rest )
140 end
141 return matches.uniq
142 end
143
144 # A predicate filters a node-set with respect to an axis to produce a
145 # new node-set. For each node in the node-set to be filtered, the
146 # PredicateExpr is evaluated with that node as the context node, with
147 # the number of nodes in the node-set as the context size, and with the
148 # proximity position of the node in the node-set with respect to the
149 # axis as the context position; if PredicateExpr evaluates to true for
150 # that node, the node is included in the new node-set; otherwise, it is
151 # not included.
152 #
153 # A PredicateExpr is evaluated by evaluating the Expr and converting
154 # the result to a boolean. If the result is a number, the result will
155 # be converted to true if the number is equal to the context position
156 # and will be converted to false otherwise; if the result is not a
157 # number, then the result will be converted as if by a call to the
158 # boolean function. Thus a location path para[3] is equivalent to
159 # para[position()=3].
160 def QuickPath::predicate( elements, path )
161 ind = 1
162 bcount = 1
163 while bcount > 0
164 bcount += 1 if path[ind] == ?[
165 bcount -= 1 if path[ind] == ?]
166 ind += 1
167 end
168 ind -= 1
169 predicate = path[1..ind-1]
170 rest = path[ind+1..-1]
171
172 # have to change 'a [=<>] b [=<>] c' into 'a [=<>] b and b [=<>] c'
173 predicate.gsub!( /([^\s(and)(or)<>=]+)\s*([<>=])\s*([^\s(and)(or)<>=]+)\s*([<>=])\s*([^\s(and)(or)<>=]+)/u ) {
174 "#$1 #$2 #$3 and #$3 #$4 #$5"
175 }
176 # Let's do some Ruby trickery to avoid some work:
177 predicate.gsub!( /&/u, "&&" )
178 predicate.gsub!( /=/u, "==" )
179 predicate.gsub!( /@(\w[-\w.]*)/u ) {
180 "attribute(\"#$1\")"
181 }
182 predicate.gsub!( /\bmod\b/u, "%" )
183 predicate.gsub!( /\b(\w[-\w.]*\()/u ) {
184 fname = $1
185 fname.gsub( /-/u, "_" )
186 }
187
188 Functions.pair = [ 0, elements.size ]
189 results = []
190 elements.each do |element|
191 Functions.pair[0] += 1
192 Functions.node = element
193 res = eval( predicate )
194 case res
195 when true
196 results << element
197 when Fixnum
198 results << element if Functions.pair[0] == res
199 when String
200 results << element
201 end
202 end
203 return filter( results, rest )
204 end
205
206 def QuickPath::attribute( name )
207 return Functions.node.attributes[name] if Functions.node.kind_of? Element
208 end
209
210 def QuickPath::name()
211 return Functions.node.name if Functions.node.kind_of? Element
212 end
213
214 def QuickPath::method_missing( id, *args )
215 begin
216 Functions.send( id.id2name, *args )
217 rescue Exception
218 raise "METHOD: #{id.id2name}(#{args.join ', '})\n#{$!.message}"
219 end
220 end
221
222 def QuickPath::function( elements, fname, rest )
223 args = parse_args( elements, rest )
224 Functions.pair = [0, elements.size]
225 results = []
226 elements.each do |element|
227 Functions.pair[0] += 1
228 Functions.node = element
229 res = Functions.send( fname, *args )
230 case res
231 when true
232 results << element
233 when Fixnum
234 results << element if Functions.pair[0] == res
235 end
236 end
237 return results
238 end
239
240 def QuickPath::parse_args( element, string )
241 # /.*?(?:\)|,)/
242 arguments = []
243 buffer = ""
244 while string and string != ""
245 c = string[0]
246 string.sub!(/^./u, "")
247 case c
248 when ?,
249 # if depth = 1, then we start a new argument
250 arguments << evaluate( buffer )
251 #arguments << evaluate( string[0..count] )
252 when ?(
253 # start a new method call
254 function( element, buffer, string )
255 buffer = ""
256 when ?)
257 # close the method call and return arguments
258 return arguments
259 else
260 buffer << c
261 end
262 end
263 ""
264 end
265 end
266 end