PureXML/Sources/XSLT/XSLTTransform.swift
Mihaela Mihaljevic 771fa4b457
XSLT/XPath conformance: close 68 Apache Xalan cases (#254)
* fix(xslt): keep namespace nodes on an included literal result element

An xsl:include'd stylesheet's declarations are absorbed after collectUnit
returns, and each literal result element resolves its 7.1.1 namespace nodes
by walking the weak parent chain back to its own included stylesheet element.
Those elements lived only in the write-only retainedRoots array, so an
optimized build released them before the deferred resolution ran and the
in-scope xmlns declarations vanished, dropping the namespace nodes the
included element should carry. The output was correct in debug and wrong in
release. Pin the retained roots across the resolution with
withExtendedLifetime. Imports were unaffected because they compile eagerly
while their tree is still a live local.

Catches Apache Xalan conformance case lre/lre05, surfaced by running the
apache/xalan-test corpus.

* fix(xslt): select a called template by import precedence, not document order

xsl:call-template looked up the target with the first match by position in the
flattened template list. Imports fold in before the including unit's own and
included templates, so when an import and an include both define a template
with the same name, the imported one was wrongly chosen. An included template
carries the including unit's higher import precedence and must win (XSLT 1.0
section 6). The lookup now picks the highest-precedence definition among the
same-name templates.

Closes Apache Xalan conformance cases namedtemplate17, namedtemplate18,
namedtemplate19, and namespace13 (removed from the xalan-test baseline). Full
suite 1608 tests green in debug and release; the Xalan suite passes.

* fix(xpath): string-value of a comment or PI node is its own data

The XPath string-value of a comment node is its character data and of a
processing-instruction node is its data (XPath 1.0 5.6, 5.7), but TreeNode
returned the empty string for both, so value-of select="comment()", and any
matching, sorting, or comparison over comment/PI nodes, produced nothing.

stringValue was conflated with the text-only concatenation that forms an
element's or root's string-value, where comment and PI descendants correctly
contribute nothing (5.1, 5.5). That concatenation now uses a separate
textContent, so an element's string-value still excludes comment and PI text
while a comment or PI node reports its own data.

Closes 24 Apache Xalan conformance cases across node, axes, position, select,
modes, conflictres, and variable (removed from the baseline). Full suite 1609
tests green in debug and release; the Xalan suite passes.

* fix(xslt): resolve top-level variables in any order, not document order

Top-level variables and parameters may reference one another regardless of
declaration order (XSLT 1.0 section 11.4), but they were evaluated once
top-to-bottom, so a forward reference (a global declared before the one it
uses) saw an undefined value and resolved to empty. Globals now evaluate to a
fixpoint: each pass re-evaluates the unsettled ones with the latest bindings,
so a dependency chain in any order settles in at most N passes, a pass that
changes nothing stops early, and a circular reference stops at the cap.

Extracted the evaluation into Transformer.evaluatedGlobals (XSLTGlobals.swift).
Closes Apache Xalan conformance cases variable33, variable34, variable35. Full
suite 1611 tests green in debug and release; the Xalan suite passes.

* fix(xslt): an empty-content variable with no select is the empty string

XSLT 1.0 section 11.2 makes <xsl:variable name="x"/> (empty content, no select)
equivalent to select="", so boolean() of it is false. It was always built as a
result-tree-fragment document node, which boolean() reports as true. A variable
with no select and empty content now yields the empty string; only non-empty
content remains a result tree fragment.

Closes Apache Xalan conformance cases boolean43 and boolean87. Full suite 1612
tests green in debug and release; the Xalan suite passes.

* fix(xpath): allow whitespace around the :: axis separator

XPath 1.0 allows whitespace between tokens, so `child :: sub` is the child axis
with node test `sub`. The parser only matched `::` immediately after the axis
name, so a spaced separator fell back to the child axis with the axis name read
as an element test, selecting nothing. parseAxis now skips whitespace after the
axis name and after `::`; on no match the reset to before the name is unchanged,
so a bare name step is unaffected.

Closes Apache Xalan conformance cases select16, select27, select28. Full suite
1613 tests green in debug and release; the Xalan suite passes.

* feat(xslt): document('') returns the stylesheet's own document

XSLT 1.0 section 12.1 makes an empty URI reference the document containing the
expression, so a stylesheet can read its own xsl:* nodes (embedded lookup
tables, self-inspection). The reference went straight to the document loader,
which has no entry for it, so document('') returned an empty node-set. The
transformer now keeps its parsed stylesheet tree and the document function
returns it for an empty reference, cached like any loaded document; a #fragment
still applies.

Closes Apache Xalan conformance cases select67, select68, idkey50, mdocs17,
namespace20. Full suite 1614 tests green in debug and release; Xalan passes.

* fix(xslt): implement unparsed-entity-uri from the source DTD

unparsed-entity-uri was a stub returning the empty string. It now reads the
source document type's unparsed (NDATA) entities, threaded to the function table
alongside the document loader, and returns the named entity's system URI; an
unknown name still returns empty.

Closes Apache Xalan conformance case expression02. Full suite 1615 tests green
in debug and release; the Xalan suite passes.

* fix(xpath): substring-after(s, '') returns s

Per the XPath 1.0 errata, an empty second argument matches at the start of the
string, so substring-after returns the whole string. The function bailed to the
empty string on an empty separator. substring-before(s, '') stays empty, as the
spec requires.

Closes Apache Xalan conformance case string143. Full suite 1615 tests green in
debug and release; the Xalan suite passes.

* fix(xslt): match a template mode by expanded name, not its prefix

XSLT 1.0 section 5.7 compares a mode by expanded name, so two prefixes bound to
the same namespace name the same mode. The prefixed QName string was stored and
compared verbatim, so apply-templates mode="foo:m" missed a template with
mode="moo:m" even when foo and moo share a namespace. Mode names on xsl:template
and xsl:apply-templates now resolve to {uri}local at parse time.

Moved the parser's declaration helpers to XSLTParserDeclarations.swift to keep
the file within the length budget.

Closes Apache Xalan conformance case modes16. Full suite 1616 tests green in
debug and release; the Xalan suite passes.

* fix(xslt): name a variable by expanded QName, not its prefix

XSLT 1.0 section 11.1 names a variable by expanded name, so two prefixes bound
to the same namespace name the same variable. The declared name and the
$prefix:local reference were compared as raw strings, so $new:x did not see a
variable declared txt:x even when new and txt share a namespace. A prefixed
declared name now resolves to {uri}local at parse time, and the XPath evaluator
falls back to the namespace-resolved name when the raw key is unbound, so a
caller-supplied raw binding still works and unprefixed names are unchanged.

Closes Apache Xalan conformance case variable55. Full suite 1617 tests green in
debug and release; the Xalan suite passes.

* fix(xslt): a match pattern predicate sees the global variables

XSLT 1.0 section 5.2 evaluates a pattern predicate with the top-level (global)
variables in scope, but pattern matching ran with no variables bound, so a
template like match="foo[. > $screen]" never matched ($screen was undefined).
The transformer supplies the global bindings to the match cache; they are
constant per transform, so they do not enter the cache key.

Closes Apache Xalan conformance cases match14 and idkey43. Full suite 1618 tests
green in debug and release; the Xalan suite passes.

* fix(emit): make a comment ending in a hyphen or containing -- well-formed

XML forbids `--` inside a comment and a `-` immediately before `-->`, so a
comment whose text ends with `-` was emitted as <!--text---> (malformed). The
serializer now inserts a space after each offending hyphen (the XSLT 1.0 16
recovery), so `text-` becomes `text- `. Applied in both the Serializer and the
streaming Writer via a shared Escaping.comment helper.

Closes Apache Xalan conformance cases output89 and output90. Full suite 1619
tests green in debug and release; the Xalan suite passes.

* fix(xslt): preserve whitespace adjacent to a CDATA section in a template

Text and CDATA are one text node in the data model, so <out> <![CDATA[test]]>
</out> is the node " test ", whose surrounding spaces must survive whitespace
stripping (XSLT 1.0 3.4). The template body dropped each whitespace-only text
node independently, so the spaces around the CDATA vanished. Adjacent text and
CDATA children now coalesce into one run, dropped only when the whole run is
whitespace; a purely whitespace run between elements is still removed.

Closes Apache Xalan conformance case whitespace13. Full suite 1620 tests green
in debug and release; the Xalan suite passes.

* fix(xslt): xsl:processing-instruction/comment keep only text-node content

XSLT 1.0 sections 7.4 and 7.6 make it an error for xsl:comment or
xsl:processing-instruction content to create a non-text node; the recovery is
to ignore the offending node together with its content. PureXML took the
string-value of all instantiated content, so a copied element leaked its text
into the PI or comment. The content now contributes only its text and CDATA
node items.

Closes Apache Xalan conformance case copy60. Full suite 1621 tests green in
debug and release; the Xalan suite passes.

* fix(xslt): xsl:attribute keeps only text-node content (errata E27)

XSLT 1.0 errata E27 makes it an error for xsl:attribute content to create a
non-text node, recovering by ignoring the offending node together with its
content (the same rule as xsl:comment/processing-instruction). PureXML took the
string-value of all instantiated content, so a copied element leaked its text
into the attribute value. The content now contributes only its text and CDATA
node items, reusing textNodesOnly.

Closes Apache Xalan conformance cases copy56 and copy58. Full suite 1622 tests
green in debug and release; the Xalan suite passes.

* fix(xslt): xsl:copy-of carries an element's inherited namespace nodes

XSLT 1.0 11.3 copies a node together with its namespace nodes, so copying an
element must reproduce its full in-scope set, including a declaration inherited
from an ancestor. copy-of reproduced only the element's own xmlns attributes,
dropping inherited ones. The inherited declarations are now added to the copied
element and the serializer's namespace fixup drops any already in the result
scope.

Closes Apache Xalan conformance cases copy09, copy27, copy48, mdocs09. Full
suite 1623 tests green in debug and release; the Xalan suite passes.

* fix(xslt): xsl:element with an unusable name passes its content through

XSLT 1.0 7.1.2 makes a name that is not a QName an error; the recovery (the
pinned element-name-not-QName "pass-through") emits the element's content
without the wrapper. The check rejected only an empty or multi-colon name, so
an undeclared prefix (none:foo) or a name that is not an NCName (this is a
string) still produced a malformed element. The name is now also rejected when
a part is not an NCName or its prefix is unbound.

Closes Apache Xalan conformance cases namespace40, namespace42, namespace43,
namespace60, namespace73, namespace79. Full suite 1624 tests green in debug and
release; the Xalan suite passes.

* fix(xslt): xsl:copy of the root node honors use-attribute-sets

Copying the root node produces no element of its own, so the use-attribute-sets
attributes have nowhere to attach on the copy and instead join the enclosing
result element (XSLT 1.0 7.5). copyInstruction dropped them for the root case;
they are now emitted ahead of the copied content so the enclosing element picks
them up.

Closes Apache Xalan conformance cases attribset27 and attribset29. Full suite
1625 tests green in debug and release; the Xalan suite passes.

* refactor(xslt): address review (canonical name/whitespace checks, html comment safety)

Review follow-ups on the conformance series:

- xsl:element name validation now uses the canonical Parsing.XMLCharacter
  .isValidName instead of a hand-rolled grapheme check, which had narrowed valid
  XML names (it dropped a name using a non-ASCII NameChar such as U+00B7).
- The template-body whitespace check reuses Parsing.XMLCharacter.isWhitespace
  instead of a third local copy of the same predicate.
- The HTML serializer applies the section-16 comment recovery too, so a
  method="html" comment ending in a hyphen (or containing two) is well-formed;
  the C14N canonicalizer keeps comments verbatim as its contract requires.

Adds regression tests for a non-ASCII NameChar element name and for html
comment hyphen-safety. Full suite 1626 tests green in debug and release; the
Xalan suite passes.
2026-06-24 00:13:14 +02:00

245 lines
12 KiB
Swift

public extension PureXML.XSLT {
/// Transforms `source` with `stylesheet`, returning the serialized result.
/// `documentLoader` resolves the URI argument of the `document()` function to
/// source text; it returns `nil` (the default) when external documents are
/// not available, which keeps `document()` from reaching the filesystem or
/// network by default.
static func transform(
stylesheet: String,
source: String,
options: PureXML.Emitting.Options = .compact,
documentLoader: @escaping (String) -> String? = { _ in nil },
baseURI: String = "",
parameters: [String: String] = [:],
) throws -> String {
let documentLoader = resolvingLoader(documentLoader, baseURI: baseURI)
let sheet = try XSLTParser.parse(stylesheet, loader: documentLoader)
let parsed = try PureXML.Parsing.Parser().parseWithDocumentType(
source,
limits: .init(allowDoctype: true),
resolver: PureXML.XSLT.loaderResolver(documentLoader),
)
let root = PureXML.Model.TreeNode(parsed.node)
let idAttributes = PureXML.XSLT.declaredIDAttributes(parsed.documentType)
Whitespace.strip(root, stylesheet: sheet)
// The stylesheet's own document, queried by `document('')` (XSLT 1.0 12.1).
let stylesheetDocument = try? PureXML.parse(stylesheet, limits: .init(allowDoctype: true))
// The source DTD's unparsed entities, by name to system URI (12.4).
let unparsedEntityURIs = parsed.documentType.unparsedEntities.mapValues(\.id.resolvedSystemID)
let transformer = Transformer(
stylesheet: sheet,
root: root,
documentLoader: documentLoader,
idAttributes: idAttributes,
parameters: parameters,
stylesheetDocument: stylesheetDocument,
unparsedEntityURIs: unparsedEntityURIs,
)
let result = transformer.run()
if let message = transformer.terminationMessage { throw XSLTError.terminated(message) }
let method = sheet.output.method ?? defaultMethod(for: result)
if method == "text" {
// Text output is never escaped, so raw markers are only removed,
// never "unescaped".
return sheet.usesRawText ? RawText.stripped(textValue(of: result)) : textValue(of: result)
}
let body: String
if method == "html" {
body = PureXML.HTML.serialize(withContentTypeMeta(result, encoding: sheet.output.encoding ?? "UTF-8"))
} else {
let fixed = XSLTNamespaceFixup.apply(result)
let prepared = withCDATASections(fixed, sheet.output.cdataSectionElements)
var emitOptions = options.applying(sheet.output)
if sheet.output.omitXMLDeclaration == nil { emitOptions.includeXMLDeclaration = true }
body = PureXML.serialize(prepared, options: emitOptions)
}
// The XML declaration stays first; the doctype follows it.
let resolved = sheet.usesRawText ? RawText.resolve(body) : body
let documentType = doctype(for: result, sheet.output, method: method)
guard !documentType.isEmpty else { return resolved }
if resolved.hasPrefix("<?xml "), let end = rangeOf("?>", in: resolved[...]) {
var prolog = String(resolved[..<end.upperBound])
var rest = String(resolved[end.upperBound...])
if rest.hasPrefix("\n") {
prolog += "\n"
rest.removeFirst()
}
return prolog + documentType + rest
}
return documentType + resolved
}
/// The default output method (16.1): html when the first element of the
/// result is named html in any case combination (with only whitespace
/// text before it), otherwise xml.
private static func defaultMethod(for node: PureXML.Model.Node) -> String {
guard case let .document(children) = node else { return "xml" }
for child in children {
switch child {
case let .element(element):
let isHTML = element.name.description.lowercased() == "html" && (element.name.namespaceURI ?? "").isEmpty
return isHTML ? "html" : "xml"
case let .text(value) where value.allSatisfy { $0 == " " || $0 == "\t" || $0 == "\n" || $0 == "\r" }:
continue
default:
return "xml"
}
}
return "xml"
}
/// Returns `node` with a `META http-equiv="Content-Type"` element
/// prepended to the children of the first `head` element (16.2: the html
/// output method should add a meta element giving the encoding).
private static func withContentTypeMeta(_ node: PureXML.Model.Node, encoding: String) -> PureXML.Model.Node {
switch node {
case let .document(children):
return .document(children.map { withContentTypeMeta($0, encoding: encoding) })
case let .element(element):
var children = element.children.map { withContentTypeMeta($0, encoding: encoding) }
let needsMeta = element.name.localName.lowercased() == "head"
&& !children.contains(where: { isContentTypeMeta($0) })
if needsMeta {
let meta = PureXML.Model.Element(
name: .init("META"),
attributes: [
.init("http-equiv", "Content-Type"),
.init("content", "text/html; charset=\(encoding)"),
],
children: [],
)
children.insert(.element(meta), at: 0)
}
return .element(.init(name: element.name, attributes: element.attributes, children: children))
default:
return node
}
}
private static func isContentTypeMeta(_ node: PureXML.Model.Node) -> Bool {
guard case let .element(element) = node, element.name.localName.lowercased() == "meta" else { return false }
return element.attributes.contains { $0.name.localName.lowercased() == "http-equiv" }
}
/// Returns `node` with the text children of any element named in `names`
/// replaced by CDATA nodes, so the serializer emits them as CDATA sections.
private static func withCDATASections(_ node: PureXML.Model.Node, _ names: Set<String>) -> PureXML.Model.Node {
guard !names.isEmpty else { return node }
switch node {
case let .document(children):
return .document(children.map { withCDATASections($0, names) })
case let .element(element):
let wrap = names.contains(element.name.localName) || names.contains(element.name.description)
let children = element.children.flatMap { child -> [PureXML.Model.Node] in
if wrap, case let .text(value) = child { return cdataNodes(value) }
return [withCDATASections(child, names)]
}
return .element(.init(name: element.name, attributes: element.attributes, children: children))
default:
return node
}
}
/// Text as CDATA nodes, with any "]]>" split across section boundaries
/// ("]]" ends one section, ">" starts the next) so no section contains
/// the terminator.
private static func cdataNodes(_ text: String) -> [PureXML.Model.Node] {
var parts: [String] = []
var remainder = text[...]
while let range = rangeOf("]]>", in: remainder) {
parts.append(String(remainder[..<range.lowerBound]))
remainder = remainder[range.upperBound...]
}
parts.append(String(remainder))
guard parts.count > 1 else { return [.cdata(text)] }
return parts.enumerated().map { offset, part in
let lead = offset > 0 ? ">" : ""
let trail = offset < parts.count - 1 ? "]]" : ""
return .cdata(lead + part + trail)
}
}
/// The first occurrence of `needle` in `haystack` (a Foundation-free
/// substring search).
private static func rangeOf(_ needle: String, in haystack: Substring) -> Range<String.Index>? {
guard !needle.isEmpty else { return nil }
var start = haystack.startIndex
while let first = haystack[start...].firstIndex(of: needle.first ?? " ") {
let end = haystack.index(first, offsetBy: needle.count, limitedBy: haystack.endIndex)
if haystack[first...].hasPrefix(needle), let end {
return first ..< end
}
start = haystack.index(after: first)
if start >= haystack.endIndex { break }
}
return nil
}
/// Wraps `loader` so a relative URI (from `document()`, `xsl:include`, or
/// `xsl:import`) is resolved against `baseURI` before loading. An empty base
/// leaves URIs as written.
private static func resolvingLoader(_ loader: @escaping (String) -> String?, baseURI: String) -> (String) -> String? {
guard !baseURI.isEmpty else { return loader }
return { reference in loader(PureXML.XInclude.URIReference.resolve(reference, against: baseURI)) }
}
/// The `<!DOCTYPE …>` prologue for the result's root element when the output
/// declares `doctype-system` (optionally with `doctype-public`), else empty.
private static func doctype(for result: PureXML.Model.Node, _ output: Output, method: String) -> String {
guard let name = rootName(of: result) else { return "" }
if let system = output.doctypeSystem {
let external = output.doctypePublic.map { "PUBLIC \"\($0)\" \"\(system)\"" } ?? "SYSTEM \"\(system)\""
return "<!DOCTYPE \(name) \(external)>\n"
}
// Without a system identifier only the html method emits a doctype
// (16.1: the xml method requires doctype-system; 16.2 allows
// public-only for html).
if method == "html", let publicID = output.doctypePublic {
return "<!DOCTYPE \(name) PUBLIC \"\(publicID)\">\n"
}
return ""
}
private static func rootName(of node: PureXML.Model.Node) -> String? {
switch node {
case let .element(element): element.name.description
case let .document(children): children.compactMap(\.element).first?.name.description
default: nil
}
}
/// Transforms `source` with `stylesheet`, returning the result tree.
static func transformToNode(
stylesheet: String,
source: String,
documentLoader: @escaping (String) -> String? = { _ in nil },
baseURI: String = "",
) throws -> PureXML.Model.Node {
let documentLoader = resolvingLoader(documentLoader, baseURI: baseURI)
let sheet = try XSLTParser.parse(stylesheet, loader: documentLoader)
let root = try PureXML.parseTree(source, limits: .init(allowDoctype: true))
Whitespace.strip(root, stylesheet: sheet)
let stylesheetDocument = try? PureXML.parse(stylesheet, limits: .init(allowDoctype: true))
let transformer = Transformer(
stylesheet: sheet,
root: root,
documentLoader: documentLoader,
stylesheetDocument: stylesheetDocument,
)
let result = transformer.run()
if let message = transformer.terminationMessage { throw XSLTError.terminated(message) }
return result
}
/// The concatenated text content of a result tree, for the `text` output
/// method: character data only, with markup, comments, and PIs dropped.
private static func textValue(of node: PureXML.Model.Node) -> String {
switch node {
case let .text(value), let .cdata(value): value
case let .document(children): children.map(textValue).joined()
case let .element(element): element.children.map(textValue).joined()
case .comment, .processingInstruction: ""
}
}
}