class REXML::XPathParser

You don't want to use this class. Really. Use XPath, which is a wrapper for this class. Believe me. You don't want to poke around in here. There is strange, dark magic at work in this code. Beware. Go back! Go back while you still can!

Constants

ALL

Expr takes a stack of path elements and a set of nodes (either a Parent or an Array and returns an Array of matching nodes

ELEMENTS
LITERAL

Public Class Methods

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

Public Instance Methods

[]=( variable_name, value ) click to toggle source
# File lib/rexml/xpath_parser.rb, line 81
def []=( variable_name, value )
  @variables[ variable_name ] = value
end
first( path_stack, node ) click to toggle source

Performs a depth-first (document order) XPath search, and returns the first match. This is the fastest, lightest way to return a single result.

FIXME: This method is incomplete!

# File lib/rexml/xpath_parser.rb, line 90
def first( path_stack, node )
  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
      r = first( path[1..-1], c )
      return r if r
    end
  when :qname
    name = path[2]
    if node.name == name
      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
get_first(path, nodeset) click to toggle source
# File lib/rexml/xpath_parser.rb, line 71
def get_first path, nodeset
  path_stack = @parser.parse( path )
  first( path_stack, nodeset )
end
match( path_stack, nodeset ) click to toggle source
# File lib/rexml/xpath_parser.rb, line 126
def match( path_stack, nodeset )
  r = expr( path_stack, nodeset )
  r
end
namespaces=( namespaces={} ) click to toggle source
# File lib/rexml/xpath_parser.rb, line 56
def namespaces=( namespaces={} )
  Functions::namespace_context = namespaces
  @namespaces = namespaces
end
parse(path, nodeset) click to toggle source
# File lib/rexml/xpath_parser.rb, line 66
def parse path, nodeset
  path_stack = @parser.parse( path )
  match( path_stack, nodeset )
end
predicate(path, nodeset) click to toggle source
# File lib/rexml/xpath_parser.rb, line 76
def predicate path, nodeset
  path_stack = @parser.parse( path )
  expr( path_stack, nodeset )
end
variables=( vars={} ) click to toggle source
# File lib/rexml/xpath_parser.rb, line 61
def variables=( vars={} )
  Functions::variables = vars
  @variables = vars
end

Private Instance Methods

compare(a, op, b) click to toggle source
# File lib/rexml/xpath_parser.rb, line 681
def compare a, op, b
  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
d_o_s( p, ns, r ) click to toggle source
# File lib/rexml/xpath_parser.rb, line 477
def d_o_s( p, ns, r )
  nt = nil
  ns.each_index do |i|
    n = ns[i]
    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
descendant_or_self( path_stack, nodeset ) click to toggle source

FIXME The next two methods are BAD MOJO! This is my achilles heel. If anybody thinks of a better way of doing this, be my guest. This really sucks, but it is a wonder it works at all. ########################################################

# File lib/rexml/xpath_parser.rb, line 470
def descendant_or_self( path_stack, nodeset )
  rs = []
  d_o_s( path_stack, nodeset, rs )
  document_order(rs.flatten.compact)
  #rs.flatten.compact
end
document_order( array_of_nodes ) click to toggle source

Reorders an array of nodes so that they are in document order It tries to do this efficiently.

FIXME: I need to get rid of this, but the issue is that most of the XPath interpreter functions as a filter, which means that we lose context going in and out of function calls. If I knew what the index of the nodes was, I wouldn't have to do this. Maybe add a document IDX for each node? Problems with mutable documents. Or, rewrite everything.

# File lib/rexml/xpath_parser.rb, line 497
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 ]
  }
  new_arry.sort{ |s1, s2| s1[0] <=> s2[0] }.collect{ |s| s[1] }
end
equality_relational_compare( set1, op, set2 ) click to toggle source
# File lib/rexml/xpath_parser.rb, line 603
def equality_relational_compare( set1, op, set2 )
  if set1.kind_of? Array and set2.kind_of? Array
    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 ) }
      return rv
    else
      res = []
      SyncEnumerator.new( set1, set2 ).each { |i1, i2|
        i1 = norm( i1 )
        i2 = norm( i2 )
        res << compare( i1, op, i2 )
      }
      return res
    end
  end
  # 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
    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 )
      return a.collect {|v| compare( Functions::number(v), op, b )}
    else
      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
    if s1 == 'true' or s1 == 'false' or s2 == 'true' or s2 == 'false'
      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
    return compare( set1, op, set2 )
  end
  return false
end
expr( path_stack, nodeset, context=nil ) click to toggle source
# File lib/rexml/xpath_parser.rb, line 153
    def expr( path_stack, nodeset, context=nil )
      node_types = ELEMENTS
      return nodeset if path_stack.length == 0 || nodeset.length == 0
      while path_stack.length > 0
        if nodeset.length == 0
          path_stack.clear
          return []
        end
        case (op = path_stack.shift)
        when :document
          nodeset = [ nodeset[0].root_node ]

        when :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 )
            if node.node_type == :element
              if node.name == name
              end
            end
            !(node.node_type == :element and
              node.name == name and
              node.namespace == ns )
          end
          node_types = ELEMENTS

        when :any
          nodeset.delete_if { |node| !node_types.include?(node.node_type) }

        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
                attrib = element.attribute( name, get_namespace(element, prefix) )
                new_nodeset << attrib if attrib
              end
            end
          when :any
            for element in nodeset
              if element.node_type == :element
                new_nodeset += element.attributes.to_a
              end
            end
          end
          nodeset = new_nodeset

        when :parent
          nodeset = nodeset.collect{|n| n.parent}.compact
          #nodeset = expr(path_stack.dclone, nodeset.collect{|n| n.parent}.compact)
          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
            subcontext[ :index ] = index+1
            pc = pred.dclone
            result = expr( pc, [node], subcontext )
            result = result[0] if result.kind_of? Array and result.length == 1
            if result.kind_of? Numeric
              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}
                new_nodeset << node if result.size > 0
              end
            else
              new_nodeset << node if result
            end
          }
          nodeset = new_nodeset
=begin
          predicate = path_stack.shift
          ns = nodeset.clone
          result = expr( predicate, ns )
          if result.kind_of? Array
            nodeset = result.zip(ns).collect{|m,n| n if m}.compact
          else
            nodeset = result ? nodeset : []
          end
=end

        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
          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
          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
          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
          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
              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 )
          right = expr( path_stack.shift, nodeset.dup, context )
          res = equality_relational_compare( left, op, right )
          return res

        when :and
          left = expr( path_stack.shift, nodeset.dup, context )
          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 )
          res = equality_relational_compare( left, op, right )
          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
          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|
              expr( arg, [n], cont )
            }
            Functions.context = cont
            res << Functions.send( func_name, *args )
          }
          return res

        end
      end # while
      return nodeset
    end
following( node ) click to toggle source
# File lib/rexml/xpath_parser.rb, line 561
def following( node )
  acc = []
  p = next_sibling_node( node )
  while p
    acc << p
    p = following_node_of( p )
  end
  acc
end
following_node_of( node ) click to toggle source
# File lib/rexml/xpath_parser.rb, line 571
def following_node_of( node )
  if node.kind_of? Element and node.children.size > 0
    return node.children[0]
  end
  return next_sibling_node(node)
end
get_namespace( node, prefix ) click to toggle source

Returns a String namespace for a node, given a prefix The rules are:

1. Use the supplied namespace mapping first.
2. If no mapping was supplied, use the context node to look up the namespace
# File lib/rexml/xpath_parser.rb, line 139
def get_namespace( node, prefix )
  if @namespaces
    return @namespaces[prefix] || ''
  else
    return node.namespace( prefix ) if node.node_type == :element
    return ''
  end
end
next_sibling_node(node) click to toggle source
# File lib/rexml/xpath_parser.rb, line 578
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
  end
  return psn
end
norm(b) click to toggle source
# File lib/rexml/xpath_parser.rb, line 590
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
preceding( node ) click to toggle source

Builds a nodeset of all of the preceding nodes of the supplied node, in reverse document order

preceding

includes every element in the document that precedes this node,

except for ancestors

# File lib/rexml/xpath_parser.rb, line 525
def preceding( node )
  ancestors = []
  p = node.parent
  while p
    ancestors << p
    p = p.parent
  end

  acc = []
  p = preceding_node_of( node )
  while p
    if ancestors.include? p
      ancestors.delete(p)
    else
      acc << p
    end
    p = preceding_node_of( p )
  end
  acc
end
preceding_node_of( node ) click to toggle source
# File lib/rexml/xpath_parser.rb, line 546
def preceding_node_of( node )
  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
recurse( nodeset ) { |node| ... } click to toggle source
# File lib/rexml/xpath_parser.rb, line 512
def recurse( nodeset, &block )
  for node in nodeset
    yield node
    recurse( node, &block ) if node.node_type == :element
  end
end