Mihaela Mihaljevic
1286659c62
Reach full XSLT 1.0 key, numbering, and document parity: - xsl:key declarations are compiled into an index over the source tree; the key() function looks nodes up by key name and value. - format-number() renders a number against a picture string (digit places, decimal point, grouping, percent), Foundation-free. - xsl:number generates the context node's position rendered as arabic, alphabetic, or roman numerals. - document() resolves an external source through an injected loader so the transform never reaches the filesystem or network by default. These hang off an XPath function-table injection mechanism: the evaluator merges an engine-supplied FunctionTable, letting XSLT register current(), key(), format-number(), and document() per evaluation. Closes #63
103 lines
4.6 KiB
Swift
103 lines
4.6 KiB
Swift
public extension PureXML.XPath {
|
|
/// A compiled XPath 1.0 expression: all thirteen axes with their
|
|
/// abbreviations, the node tests, the operator grammar (`or`, `and`, `=`,
|
|
/// `!=`, `<`, `<=`, `>`, `>=`, `+`, `-`, `*`, `div`, `mod`, unary `-`, `|`),
|
|
/// number and string literals, variable references, function calls, and
|
|
/// filter expressions, all over the four-type model (node-set, boolean,
|
|
/// number, string). Reimplemented from the XPath 1.0 specification.
|
|
struct Query: Sendable {
|
|
let expression: Expression
|
|
|
|
/// Compiles an XPath expression, throwing ``QueryError`` on a syntax error.
|
|
public init(_ path: String) throws {
|
|
expression = try Compiler.compile(path)
|
|
}
|
|
|
|
/// Evaluates the query over a node, returning the selected node-set in
|
|
/// document order. A non-node-set expression yields an empty list; use
|
|
/// ``value(over:variables:)`` for typed results.
|
|
public func evaluate(over node: PureXML.Model.Node) -> [Selection] {
|
|
Evaluator.evaluate(expression, over: node)
|
|
}
|
|
|
|
/// Evaluates the query and returns the selected elements only.
|
|
public func elements(over node: PureXML.Model.Node) -> [PureXML.Model.Element] {
|
|
evaluate(over: node).compactMap(\.element)
|
|
}
|
|
|
|
/// Evaluates the query and returns the string-value of each selection.
|
|
public func strings(over node: PureXML.Model.Node) -> [String] {
|
|
evaluate(over: node).map(\.stringValue)
|
|
}
|
|
|
|
/// Evaluates the query to a typed ``Value`` with optional variable bindings.
|
|
public func value(
|
|
over node: PureXML.Model.Node,
|
|
variables: [String: Value] = [:],
|
|
) throws -> Value {
|
|
try Evaluator.value(expression, over: node, variables: variables)
|
|
}
|
|
|
|
/// Evaluates the query over a pre-built tree and returns the matched tree
|
|
/// nodes in document order. Build the tree once (``PureXML/parseTree(_:)``)
|
|
/// and query it repeatedly; pair with ``value(at:position:size:variables:)``
|
|
/// to evaluate further expressions relative to each result.
|
|
public func nodes(over root: PureXML.Model.TreeNode) -> [PureXML.Model.TreeNode] {
|
|
Evaluator.nodes(expression, over: root)
|
|
}
|
|
|
|
/// Evaluates the query against an explicit context: a node already in a
|
|
/// tree (``PureXML/Model/TreeNode``), its one-based proximity `position`
|
|
/// within a node-set of `size`, and variable bindings. Downstream engines
|
|
/// (XSLT, Schematron) drive this per context node; `position()` and
|
|
/// `last()` reflect the supplied values.
|
|
public func value(
|
|
at node: PureXML.Model.TreeNode,
|
|
position: Int = 1,
|
|
size: Int = 1,
|
|
variables: [String: Value] = [:],
|
|
) throws -> Value {
|
|
try Evaluator.value(expression, at: node, position: position, size: size, variables: variables)
|
|
}
|
|
|
|
/// Like ``value(at:position:size:variables:)`` but with an extra function
|
|
/// table merged in (for engine-specific functions such as XSLT's `key`).
|
|
func value(
|
|
at node: PureXML.Model.TreeNode,
|
|
position: Int,
|
|
size: Int,
|
|
variables: [String: Value],
|
|
functions: FunctionTable,
|
|
) throws -> Value {
|
|
try Evaluator.value(
|
|
expression,
|
|
at: node,
|
|
position: position,
|
|
size: size,
|
|
variables: variables,
|
|
functions: functions,
|
|
)
|
|
}
|
|
|
|
/// Like ``nodes(over:)`` but with an extra function table merged in.
|
|
func nodes(over root: PureXML.Model.TreeNode, functions: FunctionTable) -> [PureXML.Model.TreeNode] {
|
|
Evaluator.nodes(expression, over: root, functions: functions)
|
|
}
|
|
|
|
/// Evaluates the query and coerces the result to a number.
|
|
public func number(over node: PureXML.Model.Node, variables: [String: Value] = [:]) throws -> Double {
|
|
try value(over: node, variables: variables).number
|
|
}
|
|
|
|
/// Evaluates the query and coerces the result to a string.
|
|
public func string(over node: PureXML.Model.Node, variables: [String: Value] = [:]) throws -> String {
|
|
try value(over: node, variables: variables).string
|
|
}
|
|
|
|
/// Evaluates the query and coerces the result to a boolean.
|
|
public func boolean(over node: PureXML.Model.Node, variables: [String: Value] = [:]) throws -> Bool {
|
|
try value(over: node, variables: variables).boolean
|
|
}
|
|
}
|
|
}
|