class REXML::XPathParser

# File lib/rexml/xpath_parser.rb, line 49
def initialize( )
 @parser = REXML::Parsers::XPathParser.new
 @namespaces = nil
 @variables = {}
end

# File lib/rexml/xpath_parser.rb, line 86
def []=( variable_name, value )
 @variables[ variable_name ] = value
end

# File lib/rexml/xpath_parser.rb, line 95
def first( path_stack, node )
 #puts "#{depth}) Entering match( #{path.inspect}, #{tree.inspect} )"
 return nil if path.size == 0
 case path[0]
 when :document
 # do nothing
 return first( path[1..-1], node )
 when :child
 for c in node.children
 #puts "#{depth}) CHILD checking #{name(c)}"
 r = first( path[1..-1], c )
 #puts "#{depth}) RETURNING #{r.inspect}" if r
 return r if r
 end
 when :qname
 name = path[2]
 #puts "#{depth}) QNAME #{name(tree)} == #{name} (path => #{path.size})"
 if node.name == name
 #puts "#{depth}) RETURNING #{tree.inspect}" if path.size == 3
 return node if path.size == 3
 return first( path[3..-1], node )
 else
 return nil
 end
 when :descendant_or_self
 r = first( path[1..-1], node )
 return r if r
 for c in node.children
 r = first( path, c )
 return r if r
 end
 when :node
 return first( path[1..-1], node )
 when :any
 return first( path[1..-1], node )
 end
 return nil
end

# File lib/rexml/xpath_parser.rb, line 73
def get_first path, nodeset
 #puts "#"*40
 path_stack = @parser.parse( path )
 #puts "PARSE: #{path} => #{path_stack.inspect}"
 #puts "PARSE: nodeset = #{nodeset.inspect}"
 first( path_stack, nodeset )
end

# File lib/rexml/xpath_parser.rb, line 136
def match( path_stack, nodeset )
 #puts "MATCH: path_stack = #{path_stack.inspect}"
 #puts "MATCH: nodeset = #{nodeset.inspect}"
 r = expr( path_stack, nodeset )
 #puts "MAIN EXPR => #{r.inspect}"
 r
end

# File lib/rexml/xpath_parser.rb, line 55
def namespaces=( namespaces={} )
 Functions::namespace_context = namespaces
 @namespaces = namespaces
end

# File lib/rexml/xpath_parser.rb, line 65
def parse path, nodeset
 #puts "#"*40
 path_stack = @parser.parse( path )
 #puts "PARSE: #{path} => #{path_stack.inspect}"
 #puts "PARSE: nodeset = #{nodeset.inspect}"
 match( path_stack, nodeset )
end

# File lib/rexml/xpath_parser.rb, line 81
def predicate path, nodeset
 path_stack = @parser.parse( path )
 expr( path_stack, nodeset )
end

# File lib/rexml/xpath_parser.rb, line 60
def variables=( vars={} )
 Functions::variables = vars
 @variables = vars
end

# File lib/rexml/xpath_parser.rb, line 779
def compare a, op, b
 #puts "COMPARE #{a.inspect}(#{a.class.name}) #{op} #{b.inspect}(#{b.class.name})"
 case op
 when :eq
 a == b
 when :neq
 a != b
 when :lt
 a < b
 when :lteq
 a <= b
 when :gt
 a > b
 when :gteq
 a >= b
 when :and
 a and b
 when :or
 a or b
 else
 false
 end
end

# File lib/rexml/xpath_parser.rb, line 544
def d_o_s( p, ns, r )
 #puts "IN DOS with #{ns.inspect}; ALREADY HAVE #{r.inspect}"
 nt = nil
 ns.each_index do |i|
 n = ns[i]
 #puts "P => #{p.inspect}"
 x = expr( p.dclone, [ n ] )
 nt = n.node_type
 d_o_s( p, n.children, x ) if nt == :element or nt == :document and n.children.size > 0
 r.concat(x) if x.size > 0
 end
end

# File lib/rexml/xpath_parser.rb, line 533
def descendant_or_self( path_stack, nodeset )
 rs = []
 #puts "#"*80
 #puts "PATH_STACK = #{path_stack.inspect}"
 #puts "NODESET = #{nodeset.collect{|n|n.inspect}.inspect}"
 d_o_s( path_stack, nodeset, rs )
 #puts "RS = #{rs.collect{|n|n.inspect}.inspect}"
 document_order(rs.flatten.compact)
 #rs.flatten.compact
end

# File lib/rexml/xpath_parser.rb, line 566
def document_order( array_of_nodes )
 new_arry = []
 array_of_nodes.each { |node|
 node_idx = []
 np = node.node_type == :attribute ? node.element : node
 while np.parent and np.parent.node_type == :element
 node_idx << np.parent.index( np )
 np = np.parent
 end
 new_arry << [ node_idx.reverse, node ]
 }
 #puts "new_arry = #{new_arry.inspect}"
 new_arry.sort{ |s1, s2| s1[0] <=> s2[0] }.collect{ |s| s[1] }
end

# File lib/rexml/xpath_parser.rb, line 686
def equality_relational_compare( set1, op, set2 )
 #puts "EQ_REL_COMP(#{set1.inspect} #{op.inspect} #{set2.inspect})"
 if set1.kind_of? Array and set2.kind_of? Array
 #puts "#{set1.size} & #{set2.size}"
 if set1.size == 1 and set2.size == 1
 set1 = set1[0]
 set2 = set2[0]
 elsif set1.size == 0 or set2.size == 0
 nd = set1.size==0 ? set2 : set1
 rv = nd.collect { |il| compare( il, op, nil ) }
 #puts "RV = #{rv.inspect}"
 return rv
 else
 res = []
 SyncEnumerator.new( set1, set2 ).each { |i1, i2|
 #puts "i1 = #{i1.inspect} (#{i1.class.name})"
 #puts "i2 = #{i2.inspect} (#{i2.class.name})"
 i1 = norm( i1 )
 i2 = norm( i2 )
 res << compare( i1, op, i2 )
 }
 return res
 end
 end
 #puts "EQ_REL_COMP: #{set1.inspect} (#{set1.class.name}), #{op}, #{set2.inspect} (#{set2.class.name})"
 #puts "COMPARING VALUES"
 # If one is nodeset and other is number, compare number to each item
 # in nodeset s.t. number op number(string(item))
 # If one is nodeset and other is string, compare string to each item
 # in nodeset s.t. string op string(item)
 # If one is nodeset and other is boolean, compare boolean to each item
 # in nodeset s.t. boolean op boolean(item)
 if set1.kind_of? Array or set2.kind_of? Array
 #puts "ISA ARRAY"
 if set1.kind_of? Array
 a = set1
 b = set2
 else
 a = set2
 b = set1
 end
 case b
 when true, false
 return a.collect {|v| compare( Functions::boolean(v), op, b ) }
 when Numeric
 return a.collect {|v| compare( Functions::number(v), op, b )}
 when /^\d+(\.\d+)?$/
 b = Functions::number( b )
 #puts "B = #{b.inspect}"
 return a.collect {|v| compare( Functions::number(v), op, b )}
 else
 #puts "Functions::string( #{b}(#{b.class.name}) ) = #{Functions::string(b)}"
 b = Functions::string( b )
 return a.collect { |v| compare( Functions::string(v), op, b ) }
 end
 else
 # If neither is nodeset,
 # If op is = or !=
 # If either boolean, convert to boolean
 # If either number, convert to number
 # Else, convert to string
 # Else
 # Convert both to numbers and compare
 s1 = set1.to_s
 s2 = set2.to_s
 #puts "EQ_REL_COMP: #{set1}=>#{s1}, #{set2}=>#{s2}"
 if s1 == 'true' or s1 == 'false' or s2 == 'true' or s2 == 'false'
 #puts "Functions::boolean(#{set1})=>#{Functions::boolean(set1)}"
 #puts "Functions::boolean(#{set2})=>#{Functions::boolean(set2)}"
 set1 = Functions::boolean( set1 )
 set2 = Functions::boolean( set2 )
 else
 if op == :eq or op == :neq
 if s1 =~ /^\d+(\.\d+)?$/ or s2 =~ /^\d+(\.\d+)?$/
 set1 = Functions::number( s1 )
 set2 = Functions::number( s2 )
 else
 set1 = Functions::string( set1 )
 set2 = Functions::string( set2 )
 end
 else
 set1 = Functions::number( set1 )
 set2 = Functions::number( set2 )
 end
 end
 #puts "EQ_REL_COMP: #{set1} #{op} #{set2}"
 #puts ">>> #{compare( set1, op, set2 )}"
 return compare( set1, op, set2 )
 end
 return false
end

# File lib/rexml/xpath_parser.rb, line 166
 def expr( path_stack, nodeset, context=nil )
 #puts "#"*15
 #puts "In expr with #{path_stack.inspect}"
 #puts "Returning" if path_stack.length == 0 || nodeset.length == 0
 node_types = ELEMENTS
 return nodeset if path_stack.length == 0 || nodeset.length == 0
 while path_stack.length > 0
 #puts "#"*5
 #puts "Path stack = #{path_stack.inspect}"
 #puts "Nodeset is #{nodeset.inspect}"
 if nodeset.length == 0
 path_stack.clear
 return []
 end
 case (op = path_stack.shift)
 when :document
 nodeset = [ nodeset[0].root_node ]
 #puts ":document, nodeset = #{nodeset.inspect}"
 when :qname
 #puts "IN QNAME"
 prefix = path_stack.shift
 name = path_stack.shift
 nodeset.delete_if do |node|
 # FIXME: This DOUBLES the time XPath searches take
 ns = get_namespace( node, prefix )
 #puts "NS = #{ns.inspect}"
 #puts "node.node_type == :element => #{node.node_type == :element}"
 if node.node_type == :element
 #puts "node.name == #{name} => #{node.name == name}"
 if node.name == name
 #puts "node.namespace == #{ns.inspect} => #{node.namespace == ns}"
 end
 end
 !(node.node_type == :element and
 node.name == name and
 node.namespace == ns )
 end
 node_types = ELEMENTS
 when :any
 #puts "ANY 1: nodeset = #{nodeset.inspect}"
 #puts "ANY 1: node_types = #{node_types.inspect}"
 nodeset.delete_if { |node| !node_types.include?(node.node_type) }
 #puts "ANY 2: nodeset = #{nodeset.inspect}"
 when :self
 # This space left intentionally blank
 when :processing_instruction
 target = path_stack.shift
 nodeset.delete_if do |node|
 (node.node_type != :processing_instruction) or
 ( target!='' and ( node.target != target ) )
 end
 when :text
 nodeset.delete_if { |node| node.node_type != :text }
 when :comment
 nodeset.delete_if { |node| node.node_type != :comment }
 when :node
 # This space left intentionally blank
 node_types = ALL
 when :child
 new_nodeset = []
 nt = nil
 nodeset.each do |node|
 nt = node.node_type
 new_nodeset += node.children if nt == :element or nt == :document
 end
 nodeset = new_nodeset
 node_types = ELEMENTS
 when :literal
 return path_stack.shift
 when :attribute
 new_nodeset = []
 case path_stack.shift
 when :qname
 prefix = path_stack.shift
 name = path_stack.shift
 for element in nodeset
 if element.node_type == :element
 #puts "Element name = #{element.name}"
 #puts "get_namespace( #{element.inspect}, #{prefix} ) = #{get_namespace(element, prefix)}"
 attrib = element.attribute( name, get_namespace(element, prefix) )
 #puts "attrib = #{attrib.inspect}"
 new_nodeset << attrib if attrib
 end
 end
 when :any
 #puts "ANY"
 for element in nodeset
 if element.node_type == :element
 new_nodeset += element.attributes.to_a
 end
 end
 end
 nodeset = new_nodeset
 when :parent
 #puts "PARENT 1: nodeset = #{nodeset}"
 nodeset = nodeset.collect{|n| n.parent}.compact
 #nodeset = expr(path_stack.dclone, nodeset.collect{|n| n.parent}.compact)
 #puts "PARENT 2: nodeset = #{nodeset.inspect}"
 node_types = ELEMENTS
 when :ancestor
 new_nodeset = []
 nodeset.each do |node|
 while node.parent
 node = node.parent
 new_nodeset << node unless new_nodeset.include? node
 end
 end
 nodeset = new_nodeset
 node_types = ELEMENTS
 when :ancestor_or_self
 new_nodeset = []
 nodeset.each do |node|
 if node.node_type == :element
 new_nodeset << node
 while ( node.parent )
 node = node.parent
 new_nodeset << node unless new_nodeset.include? node
 end
 end
 end
 nodeset = new_nodeset
 node_types = ELEMENTS
 when :predicate
 new_nodeset = []
 subcontext = { :size => nodeset.size }
 pred = path_stack.shift
 nodeset.each_with_index { |node, index|
 subcontext[ :node ] = node
 #puts "PREDICATE SETTING CONTEXT INDEX TO #{index+1}"
 subcontext[ :index ] = index+1
 pc = pred.dclone
 #puts "#{node.hash}) Recursing with #{pred.inspect} and [#{node.inspect}]"
 result = expr( pc, [node], subcontext )
 result = result[0] if result.kind_of? Array and result.length == 1
 #puts "#{node.hash}) Result = #{result.inspect} (#{result.class.name})"
 if result.kind_of? Numeric
 #puts "Adding node #{node.inspect}" if result == (index+1)
 new_nodeset << node if result == (index+1)
 elsif result.instance_of? Array
 if result.size > 0 and result.inject(false) {|k,s| s or k}
 #puts "Adding node #{node.inspect}" if result.size > 0
 new_nodeset << node if result.size > 0
 end
 else
 #puts "Adding node #{node.inspect}" if result
 new_nodeset << node if result
 end
 }
 #puts "New nodeset = #{new_nodeset.inspect}"
 #puts "Path_stack = #{path_stack.inspect}"
 nodeset = new_nodeset
 predicate = path_stack.shift
 ns = nodeset.clone
 result = expr( predicate, ns )
 #puts "Result = #{result.inspect} (#{result.class.name})"
 #puts "nodeset = #{nodeset.inspect}"
 if result.kind_of? Array
 nodeset = result.zip(ns).collect{|m,n| n if m}.compact
 else
 nodeset = result ? nodeset : []
 end
 #puts "Outgoing NS = #{nodeset.inspect}"

 when :descendant_or_self
 rv = descendant_or_self( path_stack, nodeset )
 path_stack.clear
 nodeset = rv
 node_types = ELEMENTS
 when :descendant
 results = []
 nt = nil
 nodeset.each do |node|
 nt = node.node_type
 results += expr( path_stack.dclone.unshift( :descendant_or_self ),
 node.children ) if nt == :element or nt == :document
 end
 nodeset = results
 node_types = ELEMENTS
 when :following_sibling
 #puts "FOLLOWING_SIBLING 1: nodeset = #{nodeset}"
 results = []
 nodeset.each do |node|
 next if node.parent.nil?
 all_siblings = node.parent.children
 current_index = all_siblings.index( node )
 following_siblings = all_siblings[ current_index+1 .. -1 ]
 results += expr( path_stack.dclone, following_siblings )
 end
 #puts "FOLLOWING_SIBLING 2: nodeset = #{nodeset}"
 nodeset = results
 when :preceding_sibling
 results = []
 nodeset.each do |node|
 next if node.parent.nil?
 all_siblings = node.parent.children
 current_index = all_siblings.index( node )
 preceding_siblings = all_siblings[ 0, current_index ].reverse
 results += preceding_siblings
 end
 nodeset = results
 node_types = ELEMENTS
 when :preceding
 new_nodeset = []
 nodeset.each do |node|
 new_nodeset += preceding( node )
 end
 #puts "NEW NODESET => #{new_nodeset.inspect}"
 nodeset = new_nodeset
 node_types = ELEMENTS
 when :following
 new_nodeset = []
 nodeset.each do |node|
 new_nodeset += following( node )
 end
 nodeset = new_nodeset
 node_types = ELEMENTS
 when :namespace
 #puts "In :namespace"
 new_nodeset = []
 prefix = path_stack.shift
 nodeset.each do |node|
 if (node.node_type == :element or node.node_type == :attribute)
 if @namespaces
 namespaces = @namespaces
 elsif (node.node_type == :element)
 namespaces = node.namespaces
 else
 namespaces = node.element.namesapces
 end
 #puts "Namespaces = #{namespaces.inspect}"
 #puts "Prefix = #{prefix.inspect}"
 #puts "Node.namespace = #{node.namespace}"
 if (node.namespace == namespaces[prefix])
 new_nodeset << node
 end
 end
 end
 nodeset = new_nodeset
 when :variable
 var_name = path_stack.shift
 return @variables[ var_name ]
 # :and, :or, :eq, :neq, :lt, :lteq, :gt, :gteq
 # TODO: Special case for :or and :and -- not evaluate the right
 # operand if the left alone determines result (i.e. is true for
 # :or and false for :and).
 when :eq, :neq, :lt, :lteq, :gt, :gteq, :or
 left = expr( path_stack.shift, nodeset.dup, context )
 #puts "LEFT => #{left.inspect} (#{left.class.name})"
 right = expr( path_stack.shift, nodeset.dup, context )
 #puts "RIGHT => #{right.inspect} (#{right.class.name})"
 res = equality_relational_compare( left, op, right )
 #puts "RES => #{res.inspect}"
 return res
 when :and
 left = expr( path_stack.shift, nodeset.dup, context )
 #puts "LEFT => #{left.inspect} (#{left.class.name})"
 return [] unless left
 if left.respond_to?(:inject) and !left.inject(false) {|a,b| a | b}
 return []
 end
 right = expr( path_stack.shift, nodeset.dup, context )
 #puts "RIGHT => #{right.inspect} (#{right.class.name})"
 res = equality_relational_compare( left, op, right )
 #puts "RES => #{res.inspect}"
 return res
 when :div
 left = Functions::number(expr(path_stack.shift, nodeset, context)).to_f
 right = Functions::number(expr(path_stack.shift, nodeset, context)).to_f
 return (left / right)
 when :mod
 left = Functions::number(expr(path_stack.shift, nodeset, context )).to_f
 right = Functions::number(expr(path_stack.shift, nodeset, context )).to_f
 return (left % right)
 when :mult
 left = Functions::number(expr(path_stack.shift, nodeset, context )).to_f
 right = Functions::number(expr(path_stack.shift, nodeset, context )).to_f
 return (left * right)
 when :plus
 left = Functions::number(expr(path_stack.shift, nodeset, context )).to_f
 right = Functions::number(expr(path_stack.shift, nodeset, context )).to_f
 return (left + right)
 when :minus
 left = Functions::number(expr(path_stack.shift, nodeset, context )).to_f
 right = Functions::number(expr(path_stack.shift, nodeset, context )).to_f
 return (left - right)
 when :union
 left = expr( path_stack.shift, nodeset, context )
 right = expr( path_stack.shift, nodeset, context )
 return (left | right)
 when :neg
 res = expr( path_stack, nodeset, context )
 return -(res.to_f)
 when :not
 when :function
 func_name = path_stack.shift.tr('-','_')
 arguments = path_stack.shift
 #puts "FUNCTION 0: #{func_name}(#{arguments.collect{|a|a.inspect}.join(', ')})"
 subcontext = context ? nil : { :size => nodeset.size }
 res = []
 cont = context
 nodeset.each_with_index { |n, i|
 if subcontext
 subcontext[:node] = n
 subcontext[:index] = i
 cont = subcontext
 end
 arg_clone = arguments.dclone
 args = arg_clone.collect { |arg|
 #puts "FUNCTION 1: Calling expr( #{arg.inspect}, [#{n.inspect}] )"
 expr( arg, [n], cont )
 }
 #puts "FUNCTION 2: #{func_name}(#{args.collect{|a|a.inspect}.join(', ')})"
 Functions.context = cont
 res << Functions.send( func_name, *args )
 #puts "FUNCTION 3: #{res[-1].inspect}"
 }
 return res
 end
 end # while
 #puts "EXPR returning #{nodeset.inspect}"
 return nodeset
 end

# File lib/rexml/xpath_parser.rb, line 637
def following( node )
 #puts "IN PRECEDING"
 acc = []
 p = next_sibling_node( node )
 #puts "P = #{p.inspect}"
 while p
 acc << p
 p = following_node_of( p )
 #puts "P = #{p.inspect}"
 end
 acc
end

# File lib/rexml/xpath_parser.rb, line 650
def following_node_of( node )
 #puts "NODE: #{node.inspect}"
 #puts "PREVIOUS NODE: #{node.previous_sibling_node.inspect}"
 #puts "PARENT NODE: #{node.parent}"
 if node.kind_of? Element and node.children.size > 0
 return node.children[0]
 end
 return next_sibling_node(node)
end

# File lib/rexml/xpath_parser.rb, line 152
def get_namespace( node, prefix )
 if @namespaces
 return @namespaces[prefix] || ''
 else
 return node.namespace( prefix ) if node.node_type == :element
 return ''
 end
end

# File lib/rexml/xpath_parser.rb, line 660
def next_sibling_node(node)
 psn = node.next_sibling_node
 while psn.nil?
 if node.parent.nil? or node.parent.class == Document
 return nil
 end
 node = node.parent
 psn = node.next_sibling_node
 #puts "psn = #{psn.inspect}"
 end
 return psn
end

# File lib/rexml/xpath_parser.rb, line 673
def norm b
 case b
 when true, false
 return b
 when 'true', 'false'
 return Functions::boolean( b )
 when /^\d+(\.\d+)?$/
 return Functions::number( b )
 else
 return Functions::string( b )
 end
end

# File lib/rexml/xpath_parser.rb, line 595
def preceding( node )
 #puts "IN PRECEDING"
 ancestors = []
 p = node.parent
 while p
 ancestors << p
 p = p.parent
 end
 acc = []
 p = preceding_node_of( node )
 #puts "P = #{p.inspect}"
 while p
 if ancestors.include? p
 ancestors.delete(p)
 else
 acc << p
 end
 p = preceding_node_of( p )
 #puts "P = #{p.inspect}"
 end
 acc
end

# File lib/rexml/xpath_parser.rb, line 619
def preceding_node_of( node )
 #puts "NODE: #{node.inspect}"
 #puts "PREVIOUS NODE: #{node.previous_sibling_node.inspect}"
 #puts "PARENT NODE: #{node.parent}"
 psn = node.previous_sibling_node
 if psn.nil?
 if node.parent.nil? or node.parent.class == Document
 return nil
 end
 return node.parent
 #psn = preceding_node_of( node.parent )
 end
 while psn and psn.kind_of? Element and psn.children.size > 0
 psn = psn.children[-1]
 end
 psn
end

# File lib/rexml/xpath_parser.rb, line 582
def recurse( nodeset, &block )
 for node in nodeset
 yield node
 recurse( node, &block ) if node.node_type == :element
 end
end