From 1646128b35862127dda2178196f564bc10da0b8c Mon Sep 17 00:00:00 2001 From: Mihaela Mihaljevic Date: Wed, 10 Jun 2026 13:36:59 +0200 Subject: [PATCH] feat(xslt): stylesheet namespace resolution for patterns and expressions Templates carry their in-scope xmlns bindings into match patterns (match cache keyed on pattern plus bindings) and instantiated expressions, resolving prefixed name tests by namespace URI; with bindings supplied an unprefixed test selects only the null namespace, the XPath 1.0 rule. Instruction-scope capture includes the default declaration: xsl:element honors in-scope xmlns="uri" for unprefixed names, xmlns="" keeps them namespace-free, and an unusable created name drops the wrapper, keeping content. Xalan baseline 263 -> 218 (namespace 41 -> 13). --- CHANGELOG.md | 1 + Sources/XPath/EvaluatorSteps.swift | 16 ++++++--- Sources/XPath/Query.swift | 2 ++ Sources/XSLT/XSLTElements.swift | 9 ++++- Sources/XSLT/XSLTMatchCache.swift | 29 +++++++++++----- Sources/XSLT/XSLTModel.swift | 3 ++ Sources/XSLT/XSLTParser.swift | 1 + Sources/XSLT/XSLTParserStructural.swift | 12 +++---- Sources/XSLT/XSLTRuntime.swift | 3 ++ Sources/XSLT/XSLTTransformer.swift | 17 ++++++---- Tests/Fixtures/xalan-baseline.txt | 45 ------------------------- 11 files changed, 64 insertions(+), 74 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 5f2cd44..31e7853 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,6 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added +- Stylesheet namespace resolution, eighth xalan burn-down (#130): a template carries the xmlns bindings in scope at its stylesheet element, and they flow into its match pattern (the match cache keys on pattern plus bindings) and every expression evaluated while it is instantiated, so `match="baz2:doc"` and `select="local-name(baz2:b)"` resolve the prefix against the stylesheet and match by namespace URI; with bindings supplied the XPath 1.0 rule applies exactly, an unprefixed name test selecting only the null namespace. The instruction-scope namespace capture includes the default declaration, so `xsl:element` honors an in-scope `xmlns="uri"` for its unprefixed created names, an in-scope `xmlns=""` keeps them namespace-free (undeclared in the result when an inherited default would capture them), and an unusable created name (`:foo`) drops the wrapper and keeps the content, the Xalan recovery. Baseline 263 to 218 (namespace 41 to 13, axes 16, sort 18, output unchanged at 34, the rest spread). - Keys, ids, and doctyped sources, seventh xalan burn-down (#130): `key()` and `document()` read the string value of attribute and namespace node arguments instead of dropping them (the Muenchian grouping idiom works); match patterns evaluate with the XSLT function table, so `key('k', 'v')` and `id('x')` patterns match (a key/id pattern branch is also no longer prefixed with `//`); and the XSLT entry points parse sources, stylesheets, and `document()` loads with doctypes allowed, which the conformance corpora use throughout. Baseline 292 to 263 (idkey 39 to 16, the rest spread). - Templates over attribute and namespace nodes, sixth xalan burn-down (#130): xsl:apply-templates and xsl:for-each now keep attribute and namespace nodes in their selections instead of dropping them at the tree-node conversion. The evaluation context carries the non-tree current node (its owner element backs the tree-only machinery), XPath evaluation and current() start from it, match patterns select attribute nodes (the match cache keeps attribute identities, owner plus name, alongside tree identities), the built-in rules copy an attribute's or namespace's value as text, xsl:copy copies the focused attribute or namespace declaration itself, and an attribute result arriving after element content is ignored (the XSLT recovery). Sorting and apply-imports work over the generalized node kind. Baseline 352 to 292 (axes 35 to 16, copy 29 to 16, attribset 18 to 13, the rest spread). - Output methods in depth, fifth xalan burn-down (#130): `disable-output-escaping` on xsl:value-of and xsl:text (raw text travels bracketed by private-use sentinels and the serializer's escaping is undone after the fact; a string extracted from a result tree fragment loses the markers per 16.4, so the variable round-trip case re-escapes); the default output method is html when the first result element is named html with a null namespace (16.1); the xml method writes the XML declaration unless `omit-xml-declaration="yes"` (the spec default, with the caller's emit options as fallback only on explicit stylesheet silence); the html method injects `META http-equiv="Content-Type"` into head (16.2), keeps SCRIPT/STYLE raw and void elements end-tag-free case-insensitively, and escapes U+00A0-U+00FF to the HTML 4.01 Latin-1 entity names. Whitespace-only detection in stylesheet/source stripping now means XML whitespace only, so an NBSP-only text node survives. The conf comparison treats whitespace adjacent to tag boundaries as layout for non-canonical comparisons. Baseline 371 to 352 (output 49 to 30). diff --git a/Sources/XPath/EvaluatorSteps.swift b/Sources/XPath/EvaluatorSteps.swift index d2dd3f9..b27aa04 100644 --- a/Sources/XPath/EvaluatorSteps.swift +++ b/Sources/XPath/EvaluatorSteps.swift @@ -99,11 +99,17 @@ extension PureXML.XPath.Evaluator { /// local name; otherwise it falls back to the in-document prefix string (the /// behavior when no bindings are supplied). private static func qualifiedMatches(_ qualified: PureXML.Model.QualifiedName, _ name: String, _ namespaces: [String: String]) -> Bool { - if !namespaces.isEmpty, let colon = name.firstIndex(of: ":") { - let prefix = String(name[.. Value { try Evaluator.value( expression, @@ -103,6 +104,7 @@ public extension PureXML.XPath { size: size, variables: variables, functions: functions, + namespaces: namespaces, ) } diff --git a/Sources/XSLT/XSLTElements.swift b/Sources/XSLT/XSLTElements.swift index 5dde975..4bcc19f 100644 --- a/Sources/XSLT/XSLTElements.swift +++ b/Sources/XSLT/XSLTElements.swift @@ -61,7 +61,7 @@ extension PureXML.XSLT.Transformer { } else if let uri = namespaces[prefix] { name = PureXML.Model.QualifiedName(prefix: prefix, localName: name.localName, namespaceURI: uri) } - } else if !isAttribute, let defaultURI = namespaces[""] { + } else if !isAttribute, let defaultURI = namespaces[""], !defaultURI.isEmpty { name = PureXML.Model.QualifiedName(prefix: nil, localName: name.localName, namespaceURI: defaultURI) } return name @@ -71,6 +71,13 @@ extension PureXML.XSLT.Transformer { guard case let .element(nameTemplate, namespaceTemplate, namespaces, useAttributeSets, body) = instruction else { return [] } + let raw = avt(nameTemplate, context) + let parts = raw.split(separator: ":", omittingEmptySubsequences: false) + if raw.isEmpty || parts.contains(where: \.isEmpty) || parts.count > 2 { + // An unusable element name: the recovery is to emit the content + // without the wrapper element. + return instantiate(body, context).filter { if case .attribute = $0 { false } else { true } } + } let name = createdName(nameTemplate, namespaceTemplate, namespaces, context, isAttribute: false) return [buildElement(name: name, literalAttributes: [], useAttributeSets: useAttributeSets, body: body, context)] } diff --git a/Sources/XSLT/XSLTMatchCache.swift b/Sources/XSLT/XSLTMatchCache.swift index eefd09b..00ff907 100644 --- a/Sources/XSLT/XSLTMatchCache.swift +++ b/Sources/XSLT/XSLTMatchCache.swift @@ -19,26 +19,37 @@ extension PureXML.XSLT { private var matched: [String: PatternMatches] = [:] /// The identities of the tree nodes `pattern` selects over `root`. - func nodes(matching pattern: String, over root: PureXML.Model.TreeNode, functions: PureXML.XPath.FunctionTable = .init()) -> Set { - compute(pattern, root, functions).trees + func nodes( + matching pattern: String, + over root: PureXML.Model.TreeNode, + functions: PureXML.XPath.FunctionTable = .init(), + namespaces: [String: String] = [:], + ) -> Set { + compute(pattern, root, functions, namespaces).trees } /// The identities of the attribute nodes `pattern` selects over `root`. - func attributes(matching pattern: String, over root: PureXML.Model.TreeNode, functions: PureXML.XPath.FunctionTable = .init()) -> Set { - compute(pattern, root, functions).attributes + func attributes( + matching pattern: String, + over root: PureXML.Model.TreeNode, + functions: PureXML.XPath.FunctionTable = .init(), + namespaces: [String: String] = [:], + ) -> Set { + compute(pattern, root, functions, namespaces).attributes } /// Computed and cached on first use; a branch that fails to compile /// selects nothing. The function table makes `key()` and `id()` - /// patterns work. - private func compute(_ pattern: String, _ root: PureXML.Model.TreeNode, _ functions: PureXML.XPath.FunctionTable) -> PatternMatches { - if let cached = matched[pattern] { return cached } + /// patterns work; the bindings resolve prefixed name tests by URI. + private func compute(_ pattern: String, _ root: PureXML.Model.TreeNode, _ functions: PureXML.XPath.FunctionTable, _ namespaces: [String: String]) -> PatternMatches { + let key = pattern + "\u{1}" + namespaces.sorted(by: { $0.key < $1.key }).map { $0.key + "=" + $0.value }.joined(separator: ";") + if let cached = matched[key] { return cached } var result = PatternMatches() for branch in pattern.split(separator: "|") { let trimmed = branch.trimmingXMLWhitespace() let path = trimmed.hasPrefix("/") || trimmed.hasPrefix("key(") || trimmed.hasPrefix("id(") ? trimmed : "//" + trimmed guard let query = try? PureXML.XPath.Query(path), - let value = try? query.value(atNode: .tree(root), position: 1, size: 1, variables: [:], functions: functions), + let value = try? query.value(atNode: .tree(root), position: 1, size: 1, variables: [:], functions: functions, namespaces: namespaces), let selected = value.nodes else { continue } for node in selected { @@ -52,7 +63,7 @@ extension PureXML.XSLT { } } } - matched[pattern] = result + matched[key] = result return result } } diff --git a/Sources/XSLT/XSLTModel.swift b/Sources/XSLT/XSLTModel.swift index 2f73a91..6872da0 100644 --- a/Sources/XSLT/XSLTModel.swift +++ b/Sources/XSLT/XSLTModel.swift @@ -231,6 +231,9 @@ public extension PureXML.XSLT { public var importPrecedence: Int public var parameters: [Binding] public var body: [Instruction] + /// The stylesheet xmlns bindings in scope at the template, for + /// resolving prefixes in its match pattern and expressions. + public var namespaces: [String: String] = [:] } /// A compiled stylesheet: its template rules, global variables, keys, output diff --git a/Sources/XSLT/XSLTParser.swift b/Sources/XSLT/XSLTParser.swift index 99c10f1..d6283c3 100644 --- a/Sources/XSLT/XSLTParser.swift +++ b/Sources/XSLT/XSLTParser.swift @@ -197,6 +197,7 @@ extension PureXML.XSLT { importPrecedence: precedence, parameters: parameters, body: body, + namespaces: inScopeNamespaces(node).filter { !$0.key.isEmpty }, ) } diff --git a/Sources/XSLT/XSLTParserStructural.swift b/Sources/XSLT/XSLTParserStructural.swift index 531b5f3..8c8e41c 100644 --- a/Sources/XSLT/XSLTParserStructural.swift +++ b/Sources/XSLT/XSLTParserStructural.swift @@ -48,9 +48,11 @@ extension PureXML.XSLT.XSLTParser { var bindings: [String: String] = [:] var current: XSLTTree? = node while let candidate = current { - for attribute in candidate.attributes where attribute.name.prefix == "xmlns" { - if bindings[attribute.name.localName] == nil { + for attribute in candidate.attributes { + if attribute.name.prefix == "xmlns", bindings[attribute.name.localName] == nil { bindings[attribute.name.localName] = attribute.value + } else if attribute.name.prefix == nil, attribute.name.localName == "xmlns", bindings[""] == nil { + bindings[""] = attribute.value } } current = candidate.parent @@ -64,12 +66,6 @@ extension PureXML.XSLT.XSLTParser { /// and `extension-element-prefixes` in scope. static func copiedNamespaces(_ node: XSLTTree) -> [String: String] { var bindings = inScopeNamespaces(node) - var current: XSLTTree? = node - while let candidate = current { - let defaults = candidate.attributes.filter { $0.name.prefix == nil && $0.name.localName == "xmlns" } - if bindings[""] == nil, let declared = defaults.first { bindings[""] = declared.value } - current = candidate.parent - } var excludedURIs: Set = [XSLTNode.namespace] for prefix in excludedPrefixTokens(node) { let key = prefix == "#default" ? "" : prefix diff --git a/Sources/XSLT/XSLTRuntime.swift b/Sources/XSLT/XSLTRuntime.swift index 5bde172..8d92740 100644 --- a/Sources/XSLT/XSLTRuntime.swift +++ b/Sources/XSLT/XSLTRuntime.swift @@ -27,6 +27,9 @@ extension PureXML.XSLT { /// The import precedence of the template currently being instantiated, so /// `apply-imports` considers only templates below it. `.max` outside a template. var importPrecedence: Int + /// The stylesheet xmlns bindings of the template being instantiated, + /// so prefixed names in its expressions resolve by URI. + var namespaces: [String: String] = [:] init( node: PureXML.Model.TreeNode, diff --git a/Sources/XSLT/XSLTTransformer.swift b/Sources/XSLT/XSLTTransformer.swift index cf5abb0..2d5ec5d 100644 --- a/Sources/XSLT/XSLTTransformer.swift +++ b/Sources/XSLT/XSLTTransformer.swift @@ -45,7 +45,10 @@ extension PureXML.XSLT { fileprivate func bestTemplate(for node: PureXML.XPath.Node, 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) } + .filter { entry in + entry.element.mode == mode && entry.element.importPrecedence < ceiling + && (entry.element.match.map { matches(node, $0, entry.element.namespaces) } ?? false) + } .max { lhs, rhs in (lhs.element.importPrecedence, lhs.element.priority, lhs.offset) < (rhs.element.importPrecedence, rhs.element.priority, rhs.offset) @@ -53,17 +56,17 @@ extension PureXML.XSLT { .element } - func matches(_ node: PureXML.Model.TreeNode, _ pattern: String) -> Bool { - matchCache.nodes(matching: pattern, over: root, functions: patternFunctions()).contains(ObjectIdentifier(node)) + func matches(_ node: PureXML.Model.TreeNode, _ pattern: String, _ namespaces: [String: String] = [:]) -> Bool { + matchCache.nodes(matching: pattern, over: root, functions: patternFunctions(), namespaces: namespaces).contains(ObjectIdentifier(node)) } /// Pattern membership for any XPath node kind. - func matches(_ node: PureXML.XPath.Node, _ pattern: String) -> Bool { + func matches(_ node: PureXML.XPath.Node, _ pattern: String, _ namespaces: [String: String] = [:]) -> Bool { switch node { case let .tree(tree): - matches(tree, pattern) + matches(tree, pattern, namespaces) case let .attribute(owner, attribute): - matchCache.attributes(matching: pattern, over: root, functions: patternFunctions()) + matchCache.attributes(matching: pattern, over: root, functions: patternFunctions(), namespaces: namespaces) .contains(PureXML.XSLT.AttributeIdentity(owner: ObjectIdentifier(owner), name: attribute.name.description)) case .namespace: false @@ -118,6 +121,7 @@ extension PureXML.XSLT { ) -> [ResultItem] { var context = context context.importPrecedence = template.importPrecedence + context.namespaces = template.namespaces 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) @@ -184,6 +188,7 @@ extension PureXML.XSLT { decimalFormats: stylesheet.decimalFormats, documents: documentCache, ), + namespaces: context.namespaces, ) } diff --git a/Tests/Fixtures/xalan-baseline.txt b/Tests/Fixtures/xalan-baseline.txt index 03470cd..dfccaf4 100644 --- a/Tests/Fixtures/xalan-baseline.txt +++ b/Tests/Fixtures/xalan-baseline.txt @@ -49,10 +49,7 @@ copy/copy22 copy/copy27 copy/copy31 copy/copy36 -copy/copy44 -copy/copy47 copy/copy48 -copy/copy51 copy/copy56 copy/copy58 copy/copy60 @@ -86,7 +83,6 @@ impincl/impincl23 impincl/impincl25 impincl/impincl26 impincl/impincl27 -lre/lre12 match/match14 mdocs/mdocs01 mdocs/mdocs05 @@ -110,50 +106,19 @@ namedtemplate/namedtemplate16 namedtemplate/namedtemplate17 namedtemplate/namedtemplate18 namedtemplate/namedtemplate19 -namespace/namespace07 -namespace/namespace09 -namespace/namespace10 -namespace/namespace101 -namespace/namespace103 -namespace/namespace106 -namespace/namespace11 -namespace/namespace112 namespace/namespace113 -namespace/namespace12 -namespace/namespace125 -namespace/namespace126 -namespace/namespace127 -namespace/namespace128 namespace/namespace13 -namespace/namespace130 -namespace/namespace131 -namespace/namespace139 -namespace/namespace142 namespace/namespace19 namespace/namespace20 -namespace/namespace21 -namespace/namespace22 namespace/namespace23 namespace/namespace24 -namespace/namespace26 -namespace/namespace27 -namespace/namespace32 -namespace/namespace34 namespace/namespace35 -namespace/namespace37 namespace/namespace40 namespace/namespace42 namespace/namespace43 -namespace/namespace48 -namespace/namespace57 namespace/namespace60 -namespace/namespace68 namespace/namespace73 -namespace/namespace75 namespace/namespace79 -node/node04 -node/node05 -node/node06 node/node09 node/node10 node/node11 @@ -161,9 +126,6 @@ node/node12 node/node13 node/node15 numbering/numbering63 -numbering/numbering87 -numbering/numbering92 -numbering/numbering93 output/output13 output/output15 output/output17 @@ -243,13 +205,6 @@ sort/sort41 string/string130 string/string132 string/string143 -string/string30 -string/string31 -string/string32 -string/string33 -string/string34 -string/string35 -string/string36 variable/variable29 variable/variable31 variable/variable32