PureXML/Sources/XSLT/XSLTTransformer.swift
Mihaela Mihaljevic 7ce6b4da73 feat(xslt): template parameters and modes
Honor xsl:param defaults, xsl:with-param on apply-templates and
call-template, and mode on templates and apply-templates. A passed parameter
overrides the declared default; a mode routes nodes only to templates of that
mode, and the built-in rules recurse in the same mode. Add the parity-
completion epic to the roadmap.

Closes #62
2026-06-08 07:48:05 +02:00

352 lines
14 KiB
Swift

/// One produced item: a node for the result tree, or an attribute to attach to
/// the enclosing element. File-scope and private.
private enum ResultItem {
case node(PureXML.Model.Node)
case attribute(PureXML.Model.Attribute)
}
/// The evaluation context during instantiation. File-scope and private.
private struct XSLTContext {
var node: PureXML.Model.TreeNode
var position: Int
var size: Int
var variables: [String: PureXML.XPath.Value]
}
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
fileprivate 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?) -> Template? {
stylesheet.templates.enumerated()
.filter { $0.element.mode == mode && ($0.element.match.map { matches(node, $0) } ?? false) }
.max { lhs, rhs in (lhs.element.priority, lhs.offset) < (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)
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
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 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,
)
}
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
}
}
private func structuralEvaluate(_ instruction: PureXML.XSLT.Instruction, _ context: XSLTContext) -> [ResultItem] {
switch instruction {
case let .literalElement(name, attributes, body):
[buildElement(name: name, literalAttributes: attributes, body: body, context)]
case let .element(nameTemplate, body):
[buildElement(name: .init(avt(nameTemplate, context)), literalAttributes: [], 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)
default:
[]
}
}
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: [], 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],
body: [PureXML.XSLT.Instruction],
_ context: XSLTContext,
) -> ResultItem {
var 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: attributes, children: children)))
}
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) ?? ""
}
}
public extension PureXML.XSLT {
/// Transforms `source` with `stylesheet`, returning the serialized result.
static func transform(
stylesheet: String,
source: String,
options: PureXML.Emitting.Options = .compact,
) throws -> String {
try PureXML.serialize(transformToNode(stylesheet: stylesheet, source: source), options: options)
}
/// Transforms `source` with `stylesheet`, returning the result tree.
static func transformToNode(stylesheet: String, source: String) throws -> PureXML.Model.Node {
let sheet = try XSLTParser.parse(stylesheet)
let root = try PureXML.parseTree(source)
return Transformer(stylesheet: sheet, root: root).run()
}
}