1 require 'rexml/namespace'
2 require 'rexml/xmltokens'
3
4 module REXML
5 module Parsers
6 # You don't want to use this class. Really. Use XPath, which is a wrapper
7 # for this class. Believe me. You don't want to poke around in here.
8 # There is strange, dark magic at work in this code. Beware. Go back! Go
9 # back while you still can!
10 class XPathParser
11 include XMLTokens
12 LITERAL = /^'([^']*)'|^"([^"]*)"/u
13
14 def namespaces=( namespaces )
15 Functions::namespace_context = namespaces
16 @namespaces = namespaces
17 end
18
19 def parse path
20 path.gsub!(/([\(\[])\s+/, '\1') # Strip ignorable spaces
21 path.gsub!( /\s+([\]\)])/, '\1' )
22 parsed = []
23 path = OrExpr(path, parsed)
24 parsed
25 end
26
27 def predicate path
28 parsed = []
29 Predicate( "[#{path}]", parsed )
30 parsed
31 end
32
33 def abbreviate( path )
34 path = path.kind_of?(String) ? parse( path ) : path
35 string = ""
36 document = false
37 while path.size > 0
38 op = path.shift
39 case op
40 when :node
41 when :attribute
42 string << "/" if string.size > 0
43 string << "@"
44 when :child
45 string << "/" if string.size > 0
46 when :descendant_or_self
47 string << "/"
48 when :self
49 string << "."
50 when :parent
51 string << ".."
52 when :any
53 string << "*"
54 when :text
55 string << "text()"
56 when :following, :following_sibling,
57 :ancestor, :ancestor_or_self, :descendant,
58 :namespace, :preceding, :preceding_sibling
59 string << "/" unless string.size == 0
60 string << op.to_s.tr("_", "-")
61 string << "::"
62 when :qname
63 prefix = path.shift
64 name = path.shift
65 string << prefix+":" if prefix.size > 0
66 string << name
67 when :predicate
68 string << '['
69 string << predicate_to_string( path.shift ) {|x| abbreviate( x ) }
70 string << ']'
71 when :document
72 document = true
73 when :function
74 string << path.shift
75 string << "( "
76 string << predicate_to_string( path.shift[0] ) {|x| abbreviate( x )}
77 string << " )"
78 when :literal
79 string << %Q{ "#{path.shift}" }
80 else
81 string << "/" unless string.size == 0
82 string << "UNKNOWN("
83 string << op.inspect
84 string << ")"
85 end
86 end
87 string = "/"+string if document
88 return string
89 end
90
91 def expand( path )
92 path = path.kind_of?(String) ? parse( path ) : path
93 string = ""
94 document = false
95 while path.size > 0
96 op = path.shift
97 case op
98 when :node
99 string << "node()"
100 when :attribute, :child, :following, :following_sibling,
101 :ancestor, :ancestor_or_self, :descendant, :descendant_or_self,
102 :namespace, :preceding, :preceding_sibling, :self, :parent
103 string << "/" unless string.size == 0
104 string << op.to_s.tr("_", "-")
105 string << "::"
106 when :any
107 string << "*"
108 when :qname
109 prefix = path.shift
110 name = path.shift
111 string << prefix+":" if prefix.size > 0
112 string << name
113 when :predicate
114 string << '['
115 string << predicate_to_string( path.shift ) { |x| expand(x) }
116 string << ']'
117 when :document
118 document = true
119 else
120 string << "/" unless string.size == 0
121 string << "UNKNOWN("
122 string << op.inspect
123 string << ")"
124 end
125 end
126 string = "/"+string if document
127 return string
128 end
129
130 def predicate_to_string( path, &block )
131 string = ""
132 case path[0]
133 when :and, :or, :mult, :plus, :minus, :neq, :eq, :lt, :gt, :lteq, :gteq, :div, :mod, :union
134 op = path.shift
135 case op
136 when :eq
137 op = "="
138 when :lt
139 op = "<"
140 when :gt
141 op = ">"
142 when :lteq
143 op = "<="
144 when :gteq
145 op = ">="
146 when :neq
147 op = "!="
148 when :union
149 op = "|"
150 end
151 left = predicate_to_string( path.shift, &block )
152 right = predicate_to_string( path.shift, &block )
153 string << " "
154 string << left
155 string << " "
156 string << op.to_s
157 string << " "
158 string << right
159 string << " "
160 when :function
161 path.shift
162 name = path.shift
163 string << name
164 string << "( "
165 string << predicate_to_string( path.shift, &block )
166 string << " )"
167 when :literal
168 path.shift
169 string << " "
170 string << path.shift.inspect
171 string << " "
172 else
173 string << " "
174 string << yield( path )
175 string << " "
176 end
177 return string.squeeze(" ")
178 end
179
180 private
181 #LocationPath
182 # | RelativeLocationPath
183 # | '/' RelativeLocationPath?
184 # | '//' RelativeLocationPath
185 def LocationPath path, parsed
186 #puts "LocationPath '#{path}'"
187 path = path.strip
188 if path[0] == ?/
189 parsed << :document
190 if path[1] == ?/
191 parsed << :descendant_or_self
192 parsed << :node
193 path = path[2..-1]
194 else
195 path = path[1..-1]
196 end
197 end
198 #puts parsed.inspect
199 return RelativeLocationPath( path, parsed ) if path.size > 0
200 end
201
202 #RelativeLocationPath
203 # | Step
204 # | (AXIS_NAME '::' | '@' | '') AxisSpecifier
205 # NodeTest
206 # Predicate
207 # | '.' | '..' AbbreviatedStep
208 # | RelativeLocationPath '/' Step
209 # | RelativeLocationPath '//' Step
210 AXIS = /^(ancestor|ancestor-or-self|attribute|child|descendant|descendant-or-self|following|following-sibling|namespace|parent|preceding|preceding-sibling|self)::/
211 def RelativeLocationPath path, parsed
212 #puts "RelativeLocationPath #{path}"
213 while path.size > 0
214 # (axis or @ or <child::>) nodetest predicate >
215 # OR > / Step
216 # (. or ..) >
217 if path[0] == ?.
218 if path[1] == ?.
219 parsed << :parent
220 parsed << :node
221 path = path[2..-1]
222 else
223 parsed << :self
224 parsed << :node
225 path = path[1..-1]
226 end
227 else
228 if path[0] == ?@
229 #puts "ATTRIBUTE"
230 parsed << :attribute
231 path = path[1..-1]
232 # Goto Nodetest
233 elsif path =~ AXIS
234 parsed << $1.tr('-','_').intern
235 path = $'
236 # Goto Nodetest
237 else
238 parsed << :child
239 end
240
241 #puts "NODETESTING '#{path}'"
242 n = []
243 path = NodeTest( path, n)
244 #puts "NODETEST RETURNED '#{path}'"
245
246 if path[0] == ?[
247 path = Predicate( path, n )
248 end
249
250 parsed.concat(n)
251 end
252
253 if path.size > 0
254 if path[0] == ?/
255 if path[1] == ?/
256 parsed << :descendant_or_self
257 parsed << :node
258 path = path[2..-1]
259 else
260 path = path[1..-1]
261 end
262 else
263 return path
264 end
265 end
266 end
267 return path
268 end
269
270 # Returns a 1-1 map of the nodeset
271 # The contents of the resulting array are either:
272 # true/false, if a positive match
273 # String, if a name match
274 #NodeTest
275 # | ('*' | NCNAME ':' '*' | QNAME) NameTest
276 # | NODE_TYPE '(' ')' NodeType
277 # | PI '(' LITERAL ')' PI
278 # | '[' expr ']' Predicate
279 NCNAMETEST= /^(#{NCNAME_STR}):\*/u
280 QNAME = Namespace::NAMESPLIT
281 NODE_TYPE = /^(comment|text|node)\(\s*\)/m
282 PI = /^processing-instruction\(/
283 def NodeTest path, parsed
284 #puts "NodeTest with #{path}"
285 res = nil
286 case path
287 when /^\*/
288 path = $'
289 parsed << :any
290 when NODE_TYPE
291 type = $1
292 path = $'
293 parsed << type.tr('-', '_').intern
294 when PI
295 path = $'
296 literal = nil
297 if path !~ /^\s*\)/
298 path =~ LITERAL
299 literal = $1
300 path = $'
301 raise ParseException.new("Missing ')' after processing instruction") if path[0] != ?)
302 path = path[1..-1]
303 end
304 parsed << :processing_instruction
305 parsed << (literal || '')
306 when NCNAMETEST
307 #puts "NCNAMETEST"
308 prefix = $1
309 path = $'
310 parsed << :namespace
311 parsed << prefix
312 when QNAME
313 #puts "QNAME"
314 prefix = $1
315 name = $2
316 path = $'
317 prefix = "" unless prefix
318 parsed << :qname
319 parsed << prefix
320 parsed << name
321 end
322 return path
323 end
324
325 # Filters the supplied nodeset on the predicate(s)
326 def Predicate path, parsed
327 #puts "PREDICATE with #{path}"
328 return nil unless path[0] == ?[
329 predicates = []
330 while path[0] == ?[
331 path, expr = get_group(path)
332 predicates << expr[1..-2] if expr
333 end
334 #puts "PREDICATES = #{predicates.inspect}"
335 predicates.each{ |expr|
336 #puts "ORING #{expr}"
337 preds = []
338 parsed << :predicate
339 parsed << preds
340 OrExpr(expr, preds)
341 }
342 #puts "PREDICATES = #{predicates.inspect}"
343 path
344 end
345
346 # The following return arrays of true/false, a 1-1 mapping of the
347 # supplied nodeset, except for axe(), which returns a filtered
348 # nodeset
349
350 #| OrExpr S 'or' S AndExpr
351 #| AndExpr
352 def OrExpr path, parsed
353 #puts "OR >>> #{path}"
354 n = []
355 rest = AndExpr( path, n )
356 #puts "OR <<< #{rest}"
357 if rest != path
358 while rest =~ /^\s*( or )/
359 n = [ :or, n, [] ]
360 rest = AndExpr( $', n[-1] )
361 end
362 end
363 if parsed.size == 0 and n.size != 0
364 parsed.replace(n)
365 elsif n.size > 0
366 parsed << n
367 end
368 rest
369 end
370
371 #| AndExpr S 'and' S EqualityExpr
372 #| EqualityExpr
373 def AndExpr path, parsed
374 #puts "AND >>> #{path}"
375 n = []
376 rest = EqualityExpr( path, n )
377 #puts "AND <<< #{rest}"
378 if rest != path
379 while rest =~ /^\s*( and )/
380 n = [ :and, n, [] ]
381 #puts "AND >>> #{rest}"
382 rest = EqualityExpr( $', n[-1] )
383 #puts "AND <<< #{rest}"
384 end
385 end
386 if parsed.size == 0 and n.size != 0
387 parsed.replace(n)
388 elsif n.size > 0
389 parsed << n
390 end
391 rest
392 end
393
394 #| EqualityExpr ('=' | '!=') RelationalExpr
395 #| RelationalExpr
396 def EqualityExpr path, parsed
397 #puts "EQUALITY >>> #{path}"
398 n = []
399 rest = RelationalExpr( path, n )
400 #puts "EQUALITY <<< #{rest}"
401 if rest != path
402 while rest =~ /^\s*(!?=)\s*/
403 if $1[0] == ?!
404 n = [ :neq, n, [] ]
405 else
406 n = [ :eq, n, [] ]
407 end
408 rest = RelationalExpr( $', n[-1] )
409 end
410 end
411 if parsed.size == 0 and n.size != 0
412 parsed.replace(n)
413 elsif n.size > 0
414 parsed << n
415 end
416 rest
417 end
418
419 #| RelationalExpr ('<' | '>' | '<=' | '>=') AdditiveExpr
420 #| AdditiveExpr
421 def RelationalExpr path, parsed
422 #puts "RELATION >>> #{path}"
423 n = []
424 rest = AdditiveExpr( path, n )
425 #puts "RELATION <<< #{rest}"
426 if rest != path
427 while rest =~ /^\s*([<>]=?)\s*/
428 if $1[0] == ?<
429 sym = "lt"
430 else
431 sym = "gt"
432 end
433 sym << "eq" if $1[-1] == ?=
434 n = [ sym.intern, n, [] ]
435 rest = AdditiveExpr( $', n[-1] )
436 end
437 end
438 if parsed.size == 0 and n.size != 0
439 parsed.replace(n)
440 elsif n.size > 0
441 parsed << n
442 end
443 rest
444 end
445
446 #| AdditiveExpr ('+' | S '-') MultiplicativeExpr
447 #| MultiplicativeExpr
448 def AdditiveExpr path, parsed
449 #puts "ADDITIVE >>> #{path}"
450 n = []
451 rest = MultiplicativeExpr( path, n )
452 #puts "ADDITIVE <<< #{rest}"
453 if rest != path
454 while rest =~ /^\s*(\+| -)\s*/
455 if $1[0] == ?+
456 n = [ :plus, n, [] ]
457 else
458 n = [ :minus, n, [] ]
459 end
460 rest = MultiplicativeExpr( $', n[-1] )
461 end
462 end
463 if parsed.size == 0 and n.size != 0
464 parsed.replace(n)
465 elsif n.size > 0
466 parsed << n
467 end
468 rest
469 end
470
471 #| MultiplicativeExpr ('*' | S ('div' | 'mod') S) UnaryExpr
472 #| UnaryExpr
473 def MultiplicativeExpr path, parsed
474 #puts "MULT >>> #{path}"
475 n = []
476 rest = UnaryExpr( path, n )
477 #puts "MULT <<< #{rest}"
478 if rest != path
479 while rest =~ /^\s*(\*| div | mod )\s*/
480 if $1[0] == ?*
481 n = [ :mult, n, [] ]
482 elsif $1.include?( "div" )
483 n = [ :div, n, [] ]
484 else
485 n = [ :mod, n, [] ]
486 end
487 rest = UnaryExpr( $', n[-1] )
488 end
489 end
490 if parsed.size == 0 and n.size != 0
491 parsed.replace(n)
492 elsif n.size > 0
493 parsed << n
494 end
495 rest
496 end
497
498 #| '-' UnaryExpr
499 #| UnionExpr
500 def UnaryExpr path, parsed
501 path =~ /^(\-*)/
502 path = $'
503 if $1 and (($1.size % 2) != 0)
504 mult = -1
505 else
506 mult = 1
507 end
508 parsed << :neg if mult < 0
509
510 #puts "UNARY >>> #{path}"
511 n = []
512 path = UnionExpr( path, n )
513 #puts "UNARY <<< #{path}"
514 parsed.concat( n )
515 path
516 end
517
518 #| UnionExpr '|' PathExpr
519 #| PathExpr
520 def UnionExpr path, parsed
521 #puts "UNION >>> #{path}"
522 n = []
523 rest = PathExpr( path, n )
524 #puts "UNION <<< #{rest}"
525 if rest != path
526 while rest =~ /^\s*(\|)\s*/
527 n = [ :union, n, [] ]
528 rest = PathExpr( $', n[-1] )
529 end
530 end
531 if parsed.size == 0 and n.size != 0
532 parsed.replace( n )
533 elsif n.size > 0
534 parsed << n
535 end
536 rest
537 end
538
539 #| LocationPath
540 #| FilterExpr ('/' | '//') RelativeLocationPath
541 def PathExpr path, parsed
542 path =~ /^\s*/
543 path = $'
544 #puts "PATH >>> #{path}"
545 n = []
546 rest = FilterExpr( path, n )
547 #puts "PATH <<< '#{rest}'"
548 if rest != path
549 if rest and rest[0] == ?/
550 return RelativeLocationPath(rest, n)
551 end
552 end
553 #puts "BEFORE WITH '#{rest}'"
554 rest = LocationPath(rest, n) if rest =~ /\A[\/\.\@\[\w_*]/
555 parsed.concat(n)
556 return rest
557 end
558
559 #| FilterExpr Predicate
560 #| PrimaryExpr
561 def FilterExpr path, parsed
562 #puts "FILTER >>> #{path}"
563 n = []
564 path = PrimaryExpr( path, n )
565 #puts "FILTER <<< #{path}"
566 path = Predicate(path, n) if path and path[0] == ?[
567 #puts "FILTER <<< #{path}"
568 parsed.concat(n)
569 path
570 end
571
572 #| VARIABLE_REFERENCE
573 #| '(' expr ')'
574 #| LITERAL
575 #| NUMBER
576 #| FunctionCall
577 VARIABLE_REFERENCE = /^\$(#{NAME_STR})/u
578 NUMBER = /^(\d*\.?\d+)/
579 NT = /^comment|text|processing-instruction|node$/
580 def PrimaryExpr path, parsed
581 arry = []
582 case path
583 when VARIABLE_REFERENCE
584 varname = $1
585 path = $'
586 parsed << :variable
587 parsed << varname
588 #arry << @variables[ varname ]
589 when /^(\w[-\w]*)(?:\()/
590 #puts "PrimaryExpr :: Function >>> #$1 -- '#$''"
591 fname = $1
592 tmp = $'
593 #puts "#{fname} =~ #{NT.inspect}"
594 return path if fname =~ NT
595 path = tmp
596 parsed << :function
597 parsed << fname
598 path = FunctionCall(path, parsed)
599 when NUMBER
600 #puts "LITERAL or NUMBER: #$1"
601 varname = $1.nil? ? $2 : $1
602 path = $'
603 parsed << :literal
604 parsed << (varname.include?('.') ? varname.to_f : varname.to_i)
605 when LITERAL
606 #puts "LITERAL or NUMBER: #$1"
607 varname = $1.nil? ? $2 : $1
608 path = $'
609 parsed << :literal
610 parsed << varname
611 when /^\(/ #/
612 path, contents = get_group(path)
613 contents = contents[1..-2]
614 n = []
615 OrExpr( contents, n )
616 parsed.concat(n)
617 end
618 path
619 end
620
621 #| FUNCTION_NAME '(' ( expr ( ',' expr )* )? ')'
622 def FunctionCall rest, parsed
623 path, arguments = parse_args(rest)
624 argset = []
625 for argument in arguments
626 args = []
627 OrExpr( argument, args )
628 argset << args
629 end
630 parsed << argset
631 path
632 end
633
634 # get_group( '[foo]bar' ) -> ['bar', '[foo]']
635 def get_group string
636 ind = 0
637 depth = 0
638 st = string[0,1]
639 en = (st == "(" ? ")" : "]")
640 begin
641 case string[ind,1]
642 when st
643 depth += 1
644 when en
645 depth -= 1
646 end
647 ind += 1
648 end while depth > 0 and ind < string.length
649 return nil unless depth==0
650 [string[ind..-1], string[0..ind-1]]
651 end
652
653 def parse_args( string )
654 arguments = []
655 ind = 0
656 inquot = false
657 inapos = false
658 depth = 1
659 begin
660 case string[ind]
661 when ?"
662 inquot = !inquot unless inapos
663 when ?'
664 inapos = !inapos unless inquot
665 else
666 unless inquot or inapos
667 case string[ind]
668 when ?(
669 depth += 1
670 if depth == 1
671 string = string[1..-1]
672 ind -= 1
673 end
674 when ?)
675 depth -= 1
676 if depth == 0
677 s = string[0,ind].strip
678 arguments << s unless s == ""
679 string = string[ind+1..-1]
680 end
681 when ?,
682 if depth == 1
683 s = string[0,ind].strip
684 arguments << s unless s == ""
685 string = string[ind+1..-1]
686 ind = -1
687 end
688 end
689 end
690 end
691 ind += 1
692 end while depth > 0 and ind < string.length
693 return nil unless depth==0
694 [string,arguments]
695 end
696 end
697 end
698 end