xsl:number implements all of XSLT 1.0 section 7.7: level single/multiple/any with count and from matched as patterns through the match cache, the value expression with the below-one bypass, and the format-token engine (punctuation, separator and token reuse, zero padding, alphabetic/roman/Greek sequences, digit grouping). An unmatched single/multiple count renders empty; level=any always yields a number. document() now caches per transform so repeated loads of the same URI return the identical document and generate-id() stays unique against live nodes (the idkey49 flake). Xalan baseline 557 -> 475 (numbering 84 -> 7).
123 lines
6.1 KiB
Swift
123 lines
6.1 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] {
|
|
switch context.node.kind {
|
|
case .element:
|
|
[buildElement(name: context.node.name ?? .init(""), literalAttributes: [], useAttributeSets: useAttributeSets, body: body, context)]
|
|
case .text, .cdata:
|
|
[.node(.text(context.node.value))]
|
|
default:
|
|
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)
|
|
}
|
|
}
|