PureXML/Sources/XSLT/XSLTTransformer.swift
Mihaela Mihaljevic 4f11bafa28 feat(xslt): implement xsl:apply-imports
Re-applies templates to the current node in the current mode, considering
only templates of lower import precedence than the one being instantiated,
falling back to the built-in rule when none match. Threads the current
mode and import precedence through the evaluation context, and moves the
transformer runtime types into XSLTRuntime.swift (namespaced, via private
aliases) to stay within the file-length and namespacing gates.
2026-06-09 01:49:33 +02:00

394 lines
18 KiB
Swift

/// The transformer's runtime types are defined in XSLTRuntime.swift (nested in
/// the namespace); these file-private aliases keep them unqualified here.
private typealias ResultItem = PureXML.XSLT.ResultItem
private typealias XSLTContext = PureXML.XSLT.XSLTContext
private typealias Termination = PureXML.XSLT.Termination
extension PureXML.XSLT {
/// Runs a compiled stylesheet against a source tree, producing a result tree
/// by the XSLT 1.0 processing model: apply templates from the root, match each
/// node to the highest-priority template (or the built-in rules), and
/// instantiate the matched template's sequence constructor.
struct Transformer {
let stylesheet: Stylesheet
let root: PureXML.Model.TreeNode
let documentLoader: (String) -> String?
private let keyIndex: PureXML.XSLT.KeyIndex
private let termination = Termination()
/// The `xsl:message terminate="yes"` text, if one fired during `run()`.
var terminationMessage: String? {
termination.message
}
init(stylesheet: Stylesheet, root: PureXML.Model.TreeNode, documentLoader: @escaping (String) -> String? = { _ in nil }) {
self.stylesheet = stylesheet
self.root = root
self.documentLoader = documentLoader
keyIndex = PureXML.XSLT.Library.buildKeyIndex(stylesheet: stylesheet, root: root)
}
func run() -> PureXML.Model.Node {
var variables: [String: PureXML.XPath.Value] = [:]
let baseContext = XSLTContext(node: root, position: 1, size: 1, variables: variables)
for global in stylesheet.globals {
if case let .variable(name, select, body) = global {
variables[name] = variableValue(select, body, baseContext)
}
}
let context = XSLTContext(node: root, position: 1, size: 1, variables: variables)
return .document(applyTemplates(to: [root], mode: nil, parameters: [], context).compactMap(Self.nodeOf))
}
// MARK: Template matching
fileprivate func bestTemplate(for node: PureXML.Model.TreeNode, mode: String?, below ceiling: Int = .max) -> Template? {
stylesheet.templates.enumerated()
.filter { $0.element.mode == mode && $0.element.importPrecedence < ceiling && ($0.element.match.map { matches(node, $0) } ?? false) }
.max { lhs, rhs in
(lhs.element.importPrecedence, lhs.element.priority, lhs.offset)
< (rhs.element.importPrecedence, rhs.element.priority, rhs.offset)
}?
.element
}
private func matches(_ node: PureXML.Model.TreeNode, _ pattern: String) -> Bool {
for branch in pattern.split(separator: "|") {
let trimmed = branch.trimmingXMLWhitespace()
let path = trimmed.hasPrefix("/") ? trimmed : "//" + trimmed
if let query = try? PureXML.XPath.Query(path), query.nodes(over: root).contains(where: { $0 === node }) {
return true
}
}
return false
}
// MARK: apply-templates and built-in rules
fileprivate func applyTemplates(
to nodes: [PureXML.Model.TreeNode],
mode: String?,
parameters: [Binding],
_ context: XSLTContext,
) -> [ResultItem] {
var items: [ResultItem] = []
for (offset, node) in nodes.enumerated() {
let nodeContext = XSLTContext(node: node, position: offset + 1, size: nodes.count, variables: context.variables, mode: mode)
if let template = bestTemplate(for: node, mode: mode) {
items += instantiateTemplate(template, nodeContext, passing: parameters, from: context)
} else {
items += builtInRule(node, mode: mode, nodeContext)
}
}
return items
}
/// Binds the template's parameters (a passed `with-param` wins over the
/// declared default) and instantiates its body.
fileprivate func instantiateTemplate(
_ template: Template,
_ context: XSLTContext,
passing parameters: [Binding],
from caller: XSLTContext,
) -> [ResultItem] {
var context = context
context.importPrecedence = template.importPrecedence
for parameter in template.parameters {
if let passed = parameters.first(where: { $0.name == parameter.name }) {
context.variables[parameter.name] = variableValue(passed.select, passed.body, caller)
} else {
context.variables[parameter.name] = variableValue(parameter.select, parameter.body, context)
}
}
return instantiate(template.body, context)
}
private func builtInRule(_ node: PureXML.Model.TreeNode, mode: String?, _ context: XSLTContext) -> [ResultItem] {
switch node.kind {
case .element, .document:
applyTemplates(to: node.children, mode: mode, parameters: [], context)
case .text, .cdata:
[.node(.text(node.value))]
default:
[]
}
}
// MARK: Instantiation
fileprivate func instantiate(_ body: [Instruction], _ context: XSLTContext) -> [ResultItem] {
var items: [ResultItem] = []
var context = context
for instruction in body {
if termination.message != nil { break }
if case let .variable(name, select, varBody) = instruction {
context.variables[name] = variableValue(select, varBody, context)
} else {
items += evaluate(instruction, context)
}
}
return items
}
private func variableValue(_ select: String?, _ body: [Instruction], _ context: XSLTContext) -> PureXML.XPath.Value {
if let select { return value(select, context) ?? .string("") }
return .string(Self.text(of: instantiate(body, context)))
}
// MARK: XPath helpers
fileprivate func value(_ expression: String, _ context: XSLTContext) -> PureXML.XPath.Value? {
guard let query = try? PureXML.XPath.Query(expression) else { return nil }
return try? query.value(
at: context.node,
position: context.position,
size: context.size,
variables: context.variables,
functions: PureXML.XSLT.Library.table(current: context.node, keys: keyIndex, loader: documentLoader),
)
}
fileprivate func selectNodes(_ expression: String, _ context: XSLTContext) -> [PureXML.Model.TreeNode] {
value(expression, context)?.nodes?.compactMap(\.treeNode) ?? []
}
fileprivate func string(_ expression: String, _ context: XSLTContext) -> String {
value(expression, context)?.string ?? ""
}
fileprivate func boolean(_ expression: String, _ context: XSLTContext) -> Bool {
value(expression, context)?.boolean ?? false
}
// MARK: Result helpers
fileprivate static func nodeOf(_ item: ResultItem) -> PureXML.Model.Node? {
if case let .node(node) = item { return node }
return nil
}
fileprivate static func text(of items: [ResultItem]) -> String {
items.reduce(into: "") { result, item in
if case let .node(node) = item { result += Self.stringValue(node) }
}
}
private static func stringValue(_ node: PureXML.Model.Node) -> String {
switch node {
case let .text(value), let .cdata(value): value
case let .element(element): element.children.reduce(into: "") { $0 += stringValue($1) }
case let .document(children): children.reduce(into: "") { $0 += stringValue($1) }
default: ""
}
}
}
}
extension PureXML.XSLT.Transformer {
// MARK: Instruction evaluation
fileprivate func evaluate(_ instruction: PureXML.XSLT.Instruction, _ context: XSLTContext) -> [ResultItem] {
simpleEvaluate(instruction, context) ?? structuralEvaluate(instruction, context)
}
private func simpleEvaluate(_ instruction: PureXML.XSLT.Instruction, _ context: XSLTContext) -> [ResultItem]? {
switch instruction {
case let .literalText(text): [.node(.text(text))]
case let .valueOf(select): [.node(.text(string(select, context)))]
case let .applyTemplates(select, mode, sorts, parameters):
applyTemplates(
to: sorted(selectNodes(select ?? "node()", context), sorts),
mode: mode,
parameters: parameters,
context,
)
case let .forEach(select, sorts, body): forEach(select, sorts, body, context)
case let .ifInstruction(test, body): boolean(test, context) ? instantiate(body, context) : []
case let .choose(whens, otherwise): chooseInstruction(whens, otherwise, context)
case let .copyOf(select): copyOf(select, context)
case let .callTemplate(name, parameters): callTemplate(name, parameters, context)
case .variable: []
default: nil
}
}
/// Instantiates an `xsl:message` body as its text; `terminate` records the
/// signal so the transform aborts with it. Produces no result-tree output.
private func message(_ terminate: Bool, _ body: [PureXML.XSLT.Instruction], _ context: XSLTContext) -> [ResultItem] {
if terminate, termination.message == nil {
termination.message = Self.text(of: instantiate(body, context))
}
return []
}
private func structuralEvaluate(_ instruction: PureXML.XSLT.Instruction, _ context: XSLTContext) -> [ResultItem] {
switch instruction {
case let .literalElement(name, attributes, useAttributeSets, body):
[buildElement(name: name, literalAttributes: attributes, useAttributeSets: useAttributeSets, body: body, context)]
case let .element(nameTemplate, useAttributeSets, body):
[buildElement(name: .init(avt(nameTemplate, context)), literalAttributes: [], useAttributeSets: useAttributeSets, body: body, context)]
case let .attribute(nameTemplate, body):
[.attribute(.init(avt(nameTemplate, context), Self.text(of: instantiate(body, context))))]
case let .copy(body):
copyInstruction(body, context)
case let .number(count, _, format):
[.node(.text(PureXML.XSLT.Numbering.value(of: context.node, count: count, format: format)))]
case let .comment(body):
[.node(.comment(Self.text(of: instantiate(body, context))))]
case let .processingInstruction(name, body):
[.node(.processingInstruction(target: avt(name, context), data: Self.text(of: instantiate(body, context))))]
case let .message(terminate, body):
message(terminate, body, context)
case .applyImports:
applyImports(context)
default:
[]
}
}
/// Re-applies templates to the current node in the current mode, considering
/// only those below the current template's import precedence, falling back to
/// the built-in rule when none match.
private func applyImports(_ context: XSLTContext) -> [ResultItem] {
if let template = bestTemplate(for: context.node, mode: context.mode, below: context.importPrecedence) {
return instantiateTemplate(template, context, passing: [], from: context)
}
return builtInRule(context.node, mode: context.mode, context)
}
private func forEach(
_ select: String,
_ sorts: [PureXML.XSLT.Sort],
_ body: [PureXML.XSLT.Instruction],
_ context: XSLTContext,
) -> [ResultItem] {
let nodes = sorted(selectNodes(select, context), sorts)
var items: [ResultItem] = []
for (offset, node) in nodes.enumerated() {
items += instantiate(body, XSLTContext(node: node, position: offset + 1, size: nodes.count, variables: context.variables))
}
return items
}
private func chooseInstruction(
_ whens: [PureXML.XSLT.Branch],
_ otherwise: [PureXML.XSLT.Instruction],
_ context: XSLTContext,
) -> [ResultItem] {
for branch in whens where boolean(branch.test, context) {
return instantiate(branch.body, context)
}
return instantiate(otherwise, context)
}
private func callTemplate(_ name: String, _ parameters: [PureXML.XSLT.Binding], _ context: XSLTContext) -> [ResultItem] {
guard let template = stylesheet.templates.first(where: { $0.name == name }) else { return [] }
return instantiateTemplate(template, context, passing: parameters, from: context)
}
private func copyOf(_ select: String, _ context: XSLTContext) -> [ResultItem] {
guard let nodes = value(select, context)?.nodes else {
// A non-node-set result copies as its string value.
return value(select, context).map { [.node(.text($0.string))] } ?? []
}
return nodes.map { xnode in
switch xnode {
case let .tree(tree): .node(tree.node)
case let .attribute(_, attribute): .attribute(attribute)
case let .namespace(_, prefix, uri):
.attribute(.init(prefix.isEmpty ? "xmlns" : "xmlns:\(prefix)", uri))
}
}
}
private func copyInstruction(_ body: [PureXML.XSLT.Instruction], _ context: XSLTContext) -> [ResultItem] {
switch context.node.kind {
case .element:
[buildElement(name: context.node.name ?? .init(""), literalAttributes: [], useAttributeSets: [], body: body, context)]
case .text, .cdata:
[.node(.text(context.node.value))]
default:
instantiate(body, context)
}
}
// MARK: Building elements
private func buildElement(
name: PureXML.Model.QualifiedName,
literalAttributes: [PureXML.XSLT.LiteralAttribute],
useAttributeSets: [String],
body: [PureXML.XSLT.Instruction],
_ context: XSLTContext,
) -> ResultItem {
// Attribute sets are lowest precedence, then the element's literal
// attributes, then its xsl:attribute body; a later same-named attribute
// replaces an earlier one.
var attributes = attributeSetAttributes(useAttributeSets, context, visiting: [])
attributes += literalAttributes.map { PureXML.Model.Attribute(name: $0.name, value: avt($0.value, context)) }
var children: [PureXML.Model.Node] = []
for item in instantiate(body, context) {
switch item {
case let .attribute(attribute): attributes.append(attribute)
case let .node(node): children.append(node)
}
}
return .node(.element(.init(name: name, attributes: Self.deduplicated(attributes), children: children)))
}
/// The attributes contributed by `names` and the attribute sets they include,
/// lower precedence first, with a `visiting` guard against recursive includes.
private func attributeSetAttributes(_ names: [String], _ context: XSLTContext, visiting: Set<String>) -> [PureXML.Model.Attribute] {
var result: [PureXML.Model.Attribute] = []
for name in names where !visiting.contains(name) {
guard let set = stylesheet.attributeSets[name] else { continue }
result += attributeSetAttributes(set.use, context, visiting: visiting.union([name]))
for item in instantiate(set.attributes, context) {
if case let .attribute(attribute) = item { result.append(attribute) }
}
}
return result
}
private func avt(_ template: PureXML.XSLT.ValueTemplate, _ context: XSLTContext) -> String {
template.reduce(into: "") { result, part in
switch part {
case let .literal(text): result += text
case let .expression(expression): result += string(expression, context)
}
}
}
// MARK: Sorting
private func sorted(_ nodes: [PureXML.Model.TreeNode], _ sorts: [PureXML.XSLT.Sort]) -> [PureXML.Model.TreeNode] {
guard !sorts.isEmpty else { return nodes }
return nodes.enumerated().sorted { lhs, rhs in
for sort in sorts {
let order = compareKeys(lhs.element, rhs.element, sort)
if order != 0 { return order < 0 }
}
return lhs.offset < rhs.offset
}.map(\.element)
}
private func compareKeys(_ lhs: PureXML.Model.TreeNode, _ rhs: PureXML.Model.TreeNode, _ sort: PureXML.XSLT.Sort) -> Int {
let left = keyValue(sort.select, lhs)
let right = keyValue(sort.select, rhs)
var order: Int
if sort.numeric {
let leftNumber = PureXML.XPath.Value.parseNumber(left)
let rightNumber = PureXML.XPath.Value.parseNumber(right)
order = leftNumber == rightNumber ? 0 : (leftNumber < rightNumber ? -1 : 1)
} else {
order = left == right ? 0 : (left < right ? -1 : 1)
}
return sort.descending ? -order : order
}
private func keyValue(_ expression: String, _ node: PureXML.Model.TreeNode) -> String {
guard let query = try? PureXML.XPath.Query(expression) else { return "" }
return (try? query.value(at: node).string) ?? ""
}
}