lib/ruby-1.9.1-rc1/lib/rexml/parsers/xpathparser.rb

   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{ |pred|
 336           #puts "ORING #{pred}"
 337           preds = []
 338           parsed << :predicate
 339           parsed << preds
 340           OrExpr(pred, 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