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

DEBUG
LITERAL

Public Class Methods

new (strict: false)

Source

# File lib/rexml/xpath_parser.rb, line 60
def initialize(strict: false)
  @debug = DEBUG
  @parser = REXML::Parsers::XPathParser.new
  @namespaces = nil
  @variables = {}
  @functions = FunctionsClass.new
  @attlist_mappings = nil
  @document = nil
  @element_namespaces_cache = {}
  @nest = 0
  @strict = strict
end

sort (array_of_nodes)

Source

# File lib/rexml/xpath_parser.rb, line 787
def self.sort(array_of_nodes)
  return array_of_nodes if array_of_nodes.size <= 1

  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 ]
  }
  ordered = new_arry.sort_by do |index, node|
    index
  end
  ordered.collect do |_index, node|
    node
  end
end

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.

Public Instance Methods

[]= (variable_name, value)

Source

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

first (path_stack, node)

Source

# File lib/rexml/xpath_parser.rb, line 114
def first( path_stack, node )
  return nil if path.size == 0

  case path[0]
  when :document
    # do nothing
    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
      first( path[3..-1], node )
    else
      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
    first( path[1..-1], node )
  when :any
    first( path[1..-1], node )
  else
    nil
  end
end

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!

get_first (path, node)

Source

# File lib/rexml/xpath_parser.rb, line 94
def get_first path, node
  path_stack = @parser.parse( path )
  @document = node.document
  first( path_stack, node )
end

match (path_stack, node)

Source

# File lib/rexml/xpath_parser.rb, line 151
def match(path_stack, node)
  @document = node.document
  nodeset = [node]
  result = expr(path_stack, nodeset)
  case result
  when Array # nodeset
    XPathParser.sort(result)
  else
    [result]
  end
end

namespaces= (namespaces={})

Source

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

parse (path, node)

Source

# File lib/rexml/xpath_parser.rb, line 83
def parse path, node
  path_stack = @parser.parse( path )
  if node.is_a?(Array)
    Kernel.warn("REXML::XPath.each, REXML::XPath.first, REXML::XPath.match dropped support for nodeset...", uplevel: 1)
    return [] if node.empty?
    node = node.first
  end

  match(path_stack, node)
end

predicate (path, node)

Source

# File lib/rexml/xpath_parser.rb, line 100
def predicate path, node
  path_stack = @parser.parse( path )
  match( path_stack, node )
end

variables= (vars={})

Source

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