feat(canonical): node-subset C14N with ancestor namespace and xml:* inheritance (#85)
This commit is contained in:
parent
aca0181be9
commit
e77b39a449
@ -19,6 +19,31 @@ public extension PureXML.Canonical {
|
||||
return output
|
||||
}
|
||||
|
||||
/// Canonicalizes a subtree that may sit inside a larger document (the C14N
|
||||
/// node-subset case). The apex element receives the namespace context in
|
||||
/// scope from its omitted ancestors, and inherits their in-scope `xml:*`
|
||||
/// attributes (`xml:base`, `xml:lang`, `xml:space`) when it does not set
|
||||
/// them itself, so signing a fragment yields the same bytes regardless of
|
||||
/// where the fragment sat in the document. (Inherited `xml:base` follows
|
||||
/// the C14N 1.0 nearest-ancestor rule, not 1.1 URI joining.)
|
||||
public func canonicalize(_ subtree: PureXML.Model.TreeNode) -> String {
|
||||
guard subtree.kind == .element, case let .element(apex) = subtree.node else {
|
||||
return canonicalize(subtree.node)
|
||||
}
|
||||
let ancestorNamespaces = Self.inScopeNamespaces(above: subtree)
|
||||
let inheritedXML = Self.inheritedXMLAttributes(above: subtree, apex: apex)
|
||||
var output = ""
|
||||
switch options.mode {
|
||||
case .inclusive:
|
||||
let augmented = Self.augmentedApex(apex, inheritedXML: inheritedXML, mergingNamespaces: ancestorNamespaces)
|
||||
emit(augmented, inScope: [:], rendered: [:], output: &output)
|
||||
case .exclusive:
|
||||
let augmented = Self.augmentedApex(apex, inheritedXML: inheritedXML, mergingNamespaces: nil)
|
||||
emit(augmented, inScope: ancestorNamespaces, rendered: [:], output: &output)
|
||||
}
|
||||
return output
|
||||
}
|
||||
|
||||
private func emit(
|
||||
_ node: PureXML.Model.Node,
|
||||
inScope: [String: String],
|
||||
@ -144,6 +169,68 @@ public extension PureXML.Canonical {
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: Node-subset context
|
||||
|
||||
/// The apex element with its inherited `xml:*` attributes added, and (for
|
||||
/// inclusive mode) the namespaces in scope from omitted ancestors merged in
|
||||
/// as declarations so the apex renders its full namespace context.
|
||||
private static func augmentedApex(
|
||||
_ apex: PureXML.Model.Element,
|
||||
inheritedXML: [PureXML.Model.Attribute],
|
||||
mergingNamespaces ancestorNamespaces: [String: String]?,
|
||||
) -> PureXML.Model.Element {
|
||||
var attributes = apex.attributes + inheritedXML
|
||||
if let ancestorNamespaces {
|
||||
let declared = Set(apex.attributes.map(\.name.description))
|
||||
for (prefix, uri) in ancestorNamespaces {
|
||||
let name = prefix.isEmpty ? "xmlns" : "xmlns:\(prefix)"
|
||||
if !declared.contains(name) { attributes.append(PureXML.Model.Attribute(name, uri)) }
|
||||
}
|
||||
}
|
||||
return PureXML.Model.Element(name: apex.name, attributes: attributes, children: apex.children)
|
||||
}
|
||||
|
||||
/// The namespace declarations in scope from a node's omitted ancestors,
|
||||
/// nearest ancestor winning (so an inner redeclaration is preserved).
|
||||
private static func inScopeNamespaces(above node: PureXML.Model.TreeNode) -> [String: String] {
|
||||
var result: [String: String] = [:]
|
||||
var current = node.parent
|
||||
while let ancestor = current {
|
||||
for attribute in ancestor.attributes {
|
||||
guard let prefix = declaredPrefix(of: attribute.name), result[prefix] == nil else { continue }
|
||||
result[prefix] = attribute.value
|
||||
}
|
||||
current = ancestor.parent
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
/// The `xml:*` attributes in scope from a node's omitted ancestors that the
|
||||
/// apex does not already set, nearest ancestor winning.
|
||||
private static func inheritedXMLAttributes(above node: PureXML.Model.TreeNode, apex: PureXML.Model.Element) -> [PureXML.Model.Attribute] {
|
||||
let present = Set(apex.attributes.map(\.name.description))
|
||||
var seen: Set<String> = []
|
||||
var result: [PureXML.Model.Attribute] = []
|
||||
var current = node.parent
|
||||
while let ancestor = current {
|
||||
for attribute in ancestor.attributes where attribute.name.prefix == "xml" {
|
||||
let key = attribute.name.description
|
||||
guard !present.contains(key), seen.insert(key).inserted else { continue }
|
||||
result.append(attribute)
|
||||
}
|
||||
current = ancestor.parent
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
/// The prefix a namespace declaration binds (empty for the default
|
||||
/// namespace), or nil when the attribute is not a namespace declaration.
|
||||
private static func declaredPrefix(of name: PureXML.Model.QualifiedName) -> String? {
|
||||
if name.prefix == nil, name.localName == "xmlns" { return "" }
|
||||
if name.prefix == "xmlns" { return name.localName }
|
||||
return nil
|
||||
}
|
||||
|
||||
// MARK: Escaping
|
||||
|
||||
private static func escapeText(_ value: String) -> String {
|
||||
|
||||
47
Tests/CanonicalSubsetTests.swift
Normal file
47
Tests/CanonicalSubsetTests.swift
Normal file
@ -0,0 +1,47 @@
|
||||
@testable import PureXML
|
||||
import Testing
|
||||
|
||||
@Suite("Canonical XML: node-subset canonicalization and xml:* inheritance")
|
||||
struct CanonicalSubsetTests {
|
||||
/// The document is held for the duration of each test: a TreeNode's parent
|
||||
/// link is weak, so the canonicalizer only sees a node's ancestors while the
|
||||
/// tree that owns them is alive (the standard DOM top-down ownership).
|
||||
private func canonicalize(_ xml: String, at path: [Int], _ options: PureXML.Canonical.Options) throws -> String {
|
||||
let document = try PureXML.parseTree(xml)
|
||||
var node = document
|
||||
for index in path {
|
||||
node = node.children[index]
|
||||
}
|
||||
return PureXML.Canonical.Canonicalizer(options: options).canonicalize(node)
|
||||
}
|
||||
|
||||
@Test("An inclusive subtree renders the namespaces in scope from its ancestors")
|
||||
func test_inheritedNamespace() throws {
|
||||
let output = try canonicalize("<root xmlns:p=\"urn:x\"><p:child><p:gc/></p:child></root>", at: [0, 0], .inclusive)
|
||||
#expect(output == "<p:child xmlns:p=\"urn:x\"><p:gc></p:gc></p:child>")
|
||||
}
|
||||
|
||||
@Test("A subtree inherits xml:lang and xml:space from omitted ancestors")
|
||||
func test_inheritedXMLAttributes() throws {
|
||||
let output = try canonicalize("<root xml:lang=\"en\" xml:space=\"preserve\"><child><gc/></child></root>", at: [0, 0], .inclusive)
|
||||
#expect(output == "<child xml:lang=\"en\" xml:space=\"preserve\"><gc></gc></child>")
|
||||
}
|
||||
|
||||
@Test("The apex's own xml:* attribute overrides an inherited one")
|
||||
func test_apexOverridesInherited() throws {
|
||||
let output = try canonicalize("<root xml:lang=\"en\"><child xml:lang=\"fr\"/></root>", at: [0, 0], .inclusive)
|
||||
#expect(output == "<child xml:lang=\"fr\"></child>")
|
||||
}
|
||||
|
||||
@Test("An exclusive subtree renders only the ancestor namespaces it uses")
|
||||
func test_exclusiveOnlyUsed() throws {
|
||||
let output = try canonicalize("<root xmlns:p=\"urn:x\" xmlns:q=\"urn:y\"><p:child/></root>", at: [0, 0], .exclusive)
|
||||
#expect(output == "<p:child xmlns:p=\"urn:x\"></p:child>")
|
||||
}
|
||||
|
||||
@Test("A nearer ancestor's namespace binding wins over a farther one")
|
||||
func test_nearestNamespaceWins() throws {
|
||||
let output = try canonicalize("<a xmlns:p=\"urn:far\"><b xmlns:p=\"urn:near\"><p:c/></b></a>", at: [0, 0, 0], .inclusive)
|
||||
#expect(output == "<p:c xmlns:p=\"urn:near\"></p:c>")
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user