PureXML/Sources/XSLT/XSLTElements.swift
Mihaela Mihaljevic b41678064e feat(xslt): templates over attribute and namespace nodes
apply-templates and for-each keep attribute and namespace nodes in
their selections; the context carries the non-tree current node with
its owner element backing the tree-only machinery, XPath evaluation
and current() start from it, match patterns select attribute nodes
through attribute identities in the match cache, the built-in rules
copy an attribute's or namespace's value as text, xsl:copy copies the
focused attribute or declaration itself, and an attribute result
arriving after element content is ignored (the XSLT recovery).
Sorting, for-each, and choose move to XSLTSorting.swift for the file
caps. Xalan baseline 352 -> 292 (axes 35 -> 16, copy 29 -> 16).
2026-06-10 13:24:31 +02:00

165 lines
8.4 KiB
Swift

extension PureXML.XSLT.Transformer {
/// Compares strings case-insensitively, with `caseOrder` breaking ties among
/// strings that differ only in case (the XSLT `case-order` semantics).
static func caseInsensitiveCompare(_ left: String, _ right: String, _ caseOrder: PureXML.XSLT.CaseOrder) -> Int {
let leftLower = left.lowercased()
let rightLower = right.lowercased()
if leftLower != rightLower { return leftLower < rightLower ? -1 : 1 }
if left == right { return 0 }
// Equal apart from case: codepoint order puts uppercase first.
let upperFirst = left < right
let leftFirst = caseOrder == .upperFirst ? upperFirst : !upperFirst
return leftFirst ? -1 : 1
}
/// Rewrites a literal name in an `xsl:namespace-alias`ed stylesheet namespace
/// to its result namespace and prefix; other names pass through unchanged.
func aliased(_ name: PureXML.Model.QualifiedName) -> PureXML.Model.QualifiedName {
guard let alias = stylesheet.namespaceAliases[name.namespaceURI ?? ""] else { return name }
return PureXML.Model.QualifiedName(prefix: alias.prefix, localName: name.localName, namespaceURI: alias.uri)
}
/// The attributes with duplicates by name removed, keeping the last (so a
/// later attribute overrides one from an attribute set or an earlier source).
static func deduplicated(_ attributes: [PureXML.Model.Attribute]) -> [PureXML.Model.Attribute] {
var indexByName: [String: Int] = [:]
var result: [PureXML.Model.Attribute] = []
for attribute in attributes {
if let index = indexByName[attribute.name.description] {
result[index] = attribute
} else {
indexByName[attribute.name.description] = result.count
result.append(attribute)
}
}
return result
}
/// The expanded name an xsl:element/xsl:attribute creates (7.1.2/7.1.3):
/// an explicit namespace attribute wins; otherwise a prefixed name
/// resolves against the instruction's in-scope stylesheet declarations
/// (an unprefixed attribute name stays in no namespace).
func createdName(
_ nameTemplate: PureXML.XSLT.ValueTemplate,
_ namespaceTemplate: PureXML.XSLT.ValueTemplate?,
_ namespaces: [String: String],
_ context: PureXML.XSLT.XSLTContext,
isAttribute: Bool,
) -> PureXML.Model.QualifiedName {
let raw = avt(nameTemplate, context)
var name = PureXML.Model.QualifiedName(raw)
if let namespaceTemplate {
let uri = avt(namespaceTemplate, context)
if !uri.isEmpty {
return PureXML.Model.QualifiedName(prefix: name.prefix, localName: name.localName, namespaceURI: uri)
}
return PureXML.Model.QualifiedName(prefix: nil, localName: name.localName, namespaceURI: nil)
}
if let prefix = name.prefix {
if prefix == "xml" {
name = PureXML.Model.QualifiedName(prefix: prefix, localName: name.localName, namespaceURI: "http://www.w3.org/XML/1998/namespace")
} else if let uri = namespaces[prefix] {
name = PureXML.Model.QualifiedName(prefix: prefix, localName: name.localName, namespaceURI: uri)
}
} else if !isAttribute, let defaultURI = namespaces[""] {
name = PureXML.Model.QualifiedName(prefix: nil, localName: name.localName, namespaceURI: defaultURI)
}
return name
}
func elementInstruction(_ instruction: PureXML.XSLT.Instruction, _ context: XSLTContext) -> [PureXML.XSLT.ResultItem] {
guard case let .element(nameTemplate, namespaceTemplate, namespaces, useAttributeSets, body) = instruction else {
return []
}
let name = createdName(nameTemplate, namespaceTemplate, namespaces, context, isAttribute: false)
return [buildElement(name: name, literalAttributes: [], useAttributeSets: useAttributeSets, body: body, context)]
}
func attributeInstruction(
_ nameTemplate: PureXML.XSLT.ValueTemplate,
_ namespaceTemplate: PureXML.XSLT.ValueTemplate?,
_ namespaces: [String: String],
_ body: [PureXML.XSLT.Instruction],
_ context: XSLTContext,
) -> [PureXML.XSLT.ResultItem] {
let name = createdName(nameTemplate, namespaceTemplate, namespaces, context, isAttribute: true)
return [.attribute(.init(name: name, value: Self.text(of: instantiate(body, context))))]
}
func copyInstruction(_ useAttributeSets: [String], _ body: [PureXML.XSLT.Instruction], _ context: XSLTContext) -> [PureXML.XSLT.ResultItem] {
// A non-tree current node copies itself: an attribute node yields an
// attribute result, a namespace node its declaration.
if let current = context.current {
switch current {
case let .attribute(_, attribute):
return [.attribute(attribute)]
case let .namespace(_, prefix, uri):
return [.attribute(.init(prefix.isEmpty ? "xmlns" : "xmlns:" + prefix, uri))]
case .tree:
break
}
}
switch context.node.kind {
case .element:
return [buildElement(name: context.node.name ?? .init(""), literalAttributes: [], useAttributeSets: useAttributeSets, body: body, context)]
case .text, .cdata:
return [.node(.text(context.node.value))]
case .comment:
return [.node(.comment(context.node.value))]
case .processingInstruction:
return [.node(.processingInstruction(target: context.node.name?.description ?? "", data: context.node.value))]
default:
return instantiate(body, context)
}
}
}
extension PureXML.XSLT.Transformer {
/// `xsl:number`: an explicit `value` expression rounds per the XSLT 1.0
/// rules; otherwise the level/count/from machinery numbers the context
/// node, with patterns matched through the transform's match cache.
func numberInstruction(_ instruction: PureXML.XSLT.Instruction, _ context: XSLTContext) -> String {
guard case let .number(spec) = instruction else { return "" }
let grouping = spec.groupingSeparator.flatMap { separator in
spec.groupingSize.map { (separator: separator, size: $0) }
}
if let valueExpression = spec.value {
let number = value(valueExpression, context)?.number ?? .nan
guard number.isFinite, number.rounded() >= 1 else {
return PureXML.XPath.Value.format(number)
}
return XSLTNumbering.format([Int(number.rounded())], spec.format, grouping)
}
let numbers = XSLTNumbering.numbers(of: context.node, level: spec.level, count: spec.count, from: spec.from) { node, pattern in
matches(node, pattern)
}
return XSLTNumbering.format(numbers, spec.format, grouping)
}
}
extension PureXML.XSLT.Transformer {
/// A literal result element: aliased name and attributes, the copied
/// 7.1.1 namespace declarations, then the shared element builder.
func literalResult(_ instruction: PureXML.XSLT.Instruction, _ context: PureXML.XSLT.XSLTContext) -> PureXML.XSLT.ResultItem {
guard case let .literalElement(name, attributes, namespaces, useAttributeSets, body) = instruction else {
return .node(.text(""))
}
let aliasedAttributes = attributes.map { PureXML.XSLT.LiteralAttribute(name: aliased($0.name), value: $0.value) }
// The copied namespace nodes (7.1.1) travel as xmlns attributes; the
// fixup pass reuses them and drops the ones already in scope. An
// aliased stylesheet namespace declares its result namespace instead.
var declarations: [PureXML.XSLT.LiteralAttribute] = []
for (prefix, uri) in namespaces.sorted(by: { $0.key < $1.key }) {
let alias = stylesheet.namespaceAliases[uri]
let resolvedPrefix = alias?.prefix ?? (prefix.isEmpty ? nil : prefix)
let resolvedURI = alias?.uri ?? uri
let attributeName = resolvedPrefix.map { "xmlns:" + $0 } ?? "xmlns"
declarations.append(PureXML.XSLT.LiteralAttribute(
name: PureXML.Model.QualifiedName(attributeName),
value: [.literal(resolvedURI)],
))
}
return buildElement(name: aliased(name), literalAttributes: declarations + aliasedAttributes, useAttributeSets: useAttributeSets, body: body, context)
}
}