219 lines
8.4 KiB
Swift
219 lines
8.4 KiB
Swift
/// One part of an XPointer: either a selection expression (already translated to
|
|
/// XPath) or a namespace binding from an `xmlns()` scheme that applies to the
|
|
/// expression parts that follow it. File-scope and private.
|
|
private enum PointerPart {
|
|
case expression(String)
|
|
case namespace(prefix: String, uri: String)
|
|
case range(PureXML.XPointer.RangeForm)
|
|
}
|
|
|
|
/// Scans an XPointer into its scheme parts, each already translated to an XPath
|
|
/// expression or a namespace binding. File-scope and private: an internal detail
|
|
/// of ``PureXML/XPointer/Pointer``.
|
|
private struct PointerScanner {
|
|
typealias XPointerError = PureXML.XPointer.XPointerError
|
|
|
|
private let chars: [Character]
|
|
private var index = 0
|
|
|
|
private init(_ pointer: String) {
|
|
chars = Array(pointer)
|
|
}
|
|
|
|
static func parts(of pointer: String) throws -> [PointerPart] {
|
|
let trimmed = pointer.trimmingXMLWhitespace()
|
|
guard !trimmed.isEmpty else { throw XPointerError.empty }
|
|
// A bare name with no scheme parentheses is a shorthand pointer: id(name).
|
|
if !trimmed.contains("(") {
|
|
return [.expression("id('\(trimmed)')")]
|
|
}
|
|
var scanner = PointerScanner(trimmed)
|
|
return try scanner.scanSchemes()
|
|
}
|
|
|
|
private mutating func scanSchemes() throws -> [PointerPart] {
|
|
var parts: [PointerPart] = []
|
|
while true {
|
|
skipSpace()
|
|
guard !isAtEnd else { return parts }
|
|
let scheme = scanName()
|
|
guard !scheme.isEmpty, consume("(") else { throw XPointerError.malformed }
|
|
let data = try scanData()
|
|
try parts.append(translate(scheme: scheme, data: data))
|
|
}
|
|
}
|
|
|
|
/// Reads the balanced parenthesized data after `(`, honoring quotes, and
|
|
/// consumes the closing `)`.
|
|
private mutating func scanData() throws -> String {
|
|
var depth = 1
|
|
var data = ""
|
|
var quote: Character?
|
|
while let character = peek() {
|
|
advance()
|
|
if let active = quote {
|
|
if character == active { quote = nil }
|
|
data.append(character)
|
|
continue
|
|
}
|
|
switch character {
|
|
case "'", "\"":
|
|
quote = character
|
|
case "(":
|
|
depth += 1
|
|
case ")":
|
|
depth -= 1
|
|
if depth == 0 { return data }
|
|
default:
|
|
break
|
|
}
|
|
data.append(character)
|
|
}
|
|
throw XPointerError.malformed
|
|
}
|
|
|
|
private func translate(scheme: String, data: String) throws -> PointerPart {
|
|
switch scheme {
|
|
case "xpointer", "xpath1":
|
|
if let form = PureXML.XPointer.RangeForm.parse(data) { return .range(form) }
|
|
return .expression(data)
|
|
case "element": return .expression(Self.elementToXPath(data))
|
|
case "xmlns": return try Self.namespaceBinding(data)
|
|
default: throw XPointerError.unknownScheme(scheme)
|
|
}
|
|
}
|
|
|
|
/// Parses an `xmlns(prefix=uri)` datum into a namespace binding.
|
|
private static func namespaceBinding(_ data: String) throws -> PointerPart {
|
|
guard let equals = data.firstIndex(of: "=") else { throw XPointerError.malformed }
|
|
let prefix = String(data[..<equals]).trimmingXMLWhitespace()
|
|
let uri = String(data[data.index(after: equals)...]).trimmingXMLWhitespace()
|
|
guard !prefix.isEmpty else { throw XPointerError.malformed }
|
|
return .namespace(prefix: prefix, uri: uri)
|
|
}
|
|
|
|
/// Translates an `element()` scheme datum (`id/1/2`, `/1/2`, `id`) into the
|
|
/// equivalent XPath: an id() start or the document root, then child-element
|
|
/// positions.
|
|
private static func elementToXPath(_ data: String) -> String {
|
|
let segments = data.split(separator: "/", omittingEmptySubsequences: false)
|
|
var result = ""
|
|
for (offset, segment) in segments.enumerated() {
|
|
if offset == 0 {
|
|
result = segment.isEmpty ? "" : "id('\(segment)')"
|
|
} else {
|
|
result += "/*[\(segment)]"
|
|
}
|
|
}
|
|
return result.isEmpty ? "/" : result
|
|
}
|
|
|
|
private var isAtEnd: Bool {
|
|
index >= chars.count
|
|
}
|
|
|
|
private func peek() -> Character? {
|
|
index < chars.count ? chars[index] : nil
|
|
}
|
|
|
|
private mutating func scanName() -> String {
|
|
var name = ""
|
|
while let character = peek(), character.isXMLNameContinuation {
|
|
name.append(character)
|
|
advance()
|
|
}
|
|
return name
|
|
}
|
|
|
|
@discardableResult
|
|
private mutating func consume(_ character: Character) -> Bool {
|
|
guard peek() == character else { return false }
|
|
advance()
|
|
return true
|
|
}
|
|
|
|
private mutating func advance() {
|
|
if index < chars.count { index += 1 }
|
|
}
|
|
|
|
private mutating func skipSpace() {
|
|
while let character = peek(), character == " " || character == "\t" || character == "\n" || character == "\r" {
|
|
advance()
|
|
}
|
|
}
|
|
}
|
|
|
|
public extension PureXML.XPointer {
|
|
/// A compiled XPointer over the `element()`, `xpointer()`, `xpath1()`, and
|
|
/// `xmlns()` schemes, plus the shorthand bare-name form (`name`, equivalent to
|
|
/// `id('name')`). A pointer may chain several scheme parts; selection parts are
|
|
/// tried in order and the first that selects a non-empty node-set wins (the
|
|
/// XPointer fallback rule).
|
|
///
|
|
/// `element(id/2/3)` navigates by child-element position from an id (or the
|
|
/// document root for a leading `/`); `xpointer(expr)` and `xpath1(expr)`
|
|
/// evaluate a full XPath expression; `xmlns(p=uri)` binds the prefix `p` for the
|
|
/// expression parts that follow it. Reimplemented over ``PureXML/XPath``.
|
|
struct Pointer: Sendable {
|
|
private let parts: [PointerPart]
|
|
|
|
/// Compiles an XPointer string.
|
|
public init(_ pointer: String) throws {
|
|
parts = try PointerScanner.parts(of: pointer)
|
|
}
|
|
|
|
/// Evaluates the pointer over a node, returning the first selection scheme
|
|
/// part's non-empty result in document order, or an empty list. An
|
|
/// `xmlns()` part binds a prefix for the expression parts that follow it.
|
|
public func evaluate(over node: PureXML.Model.Node) -> [PureXML.XPath.Selection] {
|
|
var namespaces: [String: String] = [:]
|
|
for part in parts {
|
|
switch part {
|
|
case let .namespace(prefix, uri):
|
|
namespaces[prefix] = uri
|
|
case let .expression(xpath):
|
|
guard let query = try? PureXML.XPath.Query(xpath) else { continue }
|
|
let result = query.evaluate(over: node, namespaces: namespaces)
|
|
if !result.isEmpty { return result }
|
|
case .range:
|
|
continue
|
|
}
|
|
}
|
|
return []
|
|
}
|
|
|
|
/// Evaluates the pointer's range parts (`range()`, `range-to()`,
|
|
/// `string-range()`), returning the first part's non-empty ranges in
|
|
/// document order, or an empty list. An `xmlns()` part binds a prefix for
|
|
/// the range parts that follow it. Use this for the XPointer range model
|
|
/// (and XInclude range inclusion); ``evaluate(over:)`` covers the
|
|
/// node-selecting schemes.
|
|
public func evaluateRanges(over node: PureXML.Model.Node) -> [PureXML.XPointer.Range] {
|
|
let root = PureXML.Model.TreeNode(node)
|
|
var namespaces: [String: String] = [:]
|
|
for part in parts {
|
|
switch part {
|
|
case let .namespace(prefix, uri):
|
|
namespaces[prefix] = uri
|
|
case let .range(form):
|
|
let ranges = form.ranges(over: root, namespaces: namespaces)
|
|
if !ranges.isEmpty { return ranges }
|
|
case .expression:
|
|
continue
|
|
}
|
|
}
|
|
return []
|
|
}
|
|
}
|
|
|
|
/// Compiles and evaluates an XPointer over a node in one step.
|
|
static func evaluate(_ pointer: String, over node: PureXML.Model.Node) throws -> [PureXML.XPath.Selection] {
|
|
try Pointer(pointer).evaluate(over: node)
|
|
}
|
|
|
|
/// Compiles and evaluates an XPointer's range parts over a node in one step.
|
|
static func evaluateRanges(_ pointer: String, over node: PureXML.Model.Node) throws -> [Range] {
|
|
try Pointer(pointer).evaluateRanges(over: node)
|
|
}
|
|
}
|