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 



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 



107
108
109
 
# File 'lib/rexml/xpath_parser.rb', line 107

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!



116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
 
# File 'lib/rexml/xpath_parser.rb', line 116

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

#get_first(path, node) ⇒ Object 



97
98
99
100
 
# File 'lib/rexml/xpath_parser.rb', line 97

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

#match(path_stack, node) ⇒ Object 



153
154
155
156
157
158
159
160
161
162
 
# File 'lib/rexml/xpath_parser.rb', line 153

def match(path_stack, node)
  nodeset = [XPathNode.new(node, position: 1)]
  result = expr(path_stack, nodeset)
  case result
  when Array # nodeset
    unnode(result).uniq
  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, node) ⇒ Object 



79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/rexml/xpath_parser.rb', line 79

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

  document = node.document
  if document
    document.__send__(:enable_cache) do
      match( path_stack, node )
    end
  else
    match( path_stack, node )
  end
end

#predicate(path, node) ⇒ Object 



102
103
104
105
 
# File 'lib/rexml/xpath_parser.rb', line 102

def predicate path, node
  path_stack = @parser.parse( path )
  match( path_stack, node )
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