Class: REXML::XPathParser

Class | REXML::XPathParser
In: | rexml/xpath_parser.rb
Parent: | Object

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!

### Methods

[]= first get_first match namespaces= new parse predicate variables=

### Included Modules

XMLTokens

### Constants

LITERAL | = | /^'([^']*)'|^"([^"]*)"/u
ALL | = | [ :attribute, :element, :text, :processing_instruction, :comment ] |  | 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 | = | [ :element ]

### Public Class methods

new( )

[Source]

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

### Public Instance methods

[]=( variable_name, value )

[Source]

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

first( path_stack, node )

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!

[Source]

    # File rexml/xpath_parser.rb, line 81
        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

get_first(path, nodeset)

[Source]

    # File rexml/xpath_parser.rb, line 59
        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

match( path_stack, nodeset )

[Source]

    # File rexml/xpath_parser.rb, line 122
        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

namespaces=( namespaces={} )

[Source]

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

parse(path, nodeset)

[Source]

    # File rexml/xpath_parser.rb, line 51
        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

predicate(path, nodeset)

[Source]

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

variables=( vars={} )

[Source]

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

[Validate]