Class: REXML::XPathParser

Inherits:
Object
  • Object
show all
Includes:
XMLTokens
Defined in:
lib/rexml/xpath_parser.rb

Overview

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!

Constant Summary collapse

LITERAL = 
/^'([^']*)'|^"([^"]*)"/u
DEBUG = 
(ENV["REXML_XPATH_PARSER_DEBUG"] == "true")

Constants included from XMLTokens

REXML::XMLTokens::NAME, REXML::XMLTokens::NAMECHAR, REXML::XMLTokens::NAME_CHAR, REXML::XMLTokens::NAME_START_CHAR, REXML::XMLTokens::NAME_STR, REXML::XMLTokens::NCNAME_STR, REXML::XMLTokens::NMTOKEN, REXML::XMLTokens::NMTOKENS, REXML::XMLTokens::REFERENCE

Instance Method Summary collapse

Constructor Details

#initialize(strict: false) ⇒ XPathParser

Returns a new instance of XPathParser.



60
61
62
63
64
65
66
67
 
# File 'lib/rexml/xpath_parser.rb', line 60

def initialize(strict: false)
  @debug = DEBUG
  @parser = REXML::Parsers::XPathParser.new
  @namespaces = nil
  @variables = {}
  @nest = 0
  @strict = strict
end

Instance Method Details

#[]=(variable_name, value) ⇒ Object 



94
95
96
 
# File 'lib/rexml/xpath_parser.rb', line 94

def []=( variable_name, value )
  @variables[ variable_name ] = value
end

#first(path_stack, node) ⇒ Object

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!



103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/rexml/xpath_parser.rb', line 103

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) ⇒ Object 



84
85
86
87
 
# File 'lib/rexml/xpath_parser.rb', line 84

def get_first path, nodeset
  path_stack = @parser.parse( path )
  first( path_stack, nodeset )
end

#match(path_stack, nodeset) ⇒ Object 



139
140
141
142
143
144
145
146
147
148
149
150
151
 
# File 'lib/rexml/xpath_parser.rb', line 139

def match(path_stack, nodeset)
  nodeset = nodeset.collect.with_index do |node, i|
    position = i + 1
    XPathNode.new(node, position: position)
  end
  result = expr(path_stack, nodeset)
  case result
  when Array # nodeset
    unnode(result)
  else
    [result]
  end
end

#namespaces=(namespaces = {}) ⇒ Object 



69
70
71
72
 
# File 'lib/rexml/xpath_parser.rb', line 69

def namespaces=( namespaces={} )
  Functions::namespace_context = namespaces
  @namespaces = namespaces
end

#parse(path, nodeset) ⇒ Object 



79
80
81
82
 
# File 'lib/rexml/xpath_parser.rb', line 79

def parse path, nodeset
  path_stack = @parser.parse( path )
  match( path_stack, nodeset )
end

#predicate(path, nodeset) ⇒ Object 



89
90
91
92
 
# File 'lib/rexml/xpath_parser.rb', line 89

def predicate path, nodeset
  path_stack = @parser.parse( path )
  match( path_stack, nodeset )
end

#variables=(vars = {}) ⇒ Object 



74
75
76
77
 
# File 'lib/rexml/xpath_parser.rb', line 74

def variables=( vars={} )
  Functions::variables = vars
  @variables = vars
end