PureXML/Sources/Schema/RelaxNGParser.swift
Mihaela Mihaljevic c628682086 feat(relaxng): QName values with dual-context resolution, instance level clean
A value of type QName compiles to its (namespace, local) pair via the
schema's xmlns/ns scope; the derivative engine threads the instance
element's in-scope bindings to value comparison in both the tree walk
and the streaming state (frames carry their bindings), so instance
prefixes and the default namespace resolve against the instance
document and unbound prefixes match nothing. Streaming also gains the
tree walk's empty-element rule. The spec suite's instance level is
fully clean: valid 289/289, invalid 291/291; only the asserted
schema-correctness class remains.
2026-06-10 10:57:14 +02:00

341 lines
15 KiB
Swift

private typealias Tree = RNGTree
/// Compiles a RELAX NG XML-syntax document into the pattern algebra, resolving
/// `include` and `externalRef` through a loader. Holds the accumulating `define`
/// table so external grammars merge into it. File-scope and private.
final class RNGCompiler {
typealias Pattern = PureXML.Schema.Pattern
typealias NameClass = PureXML.Schema.NameClass
typealias Compositor = PureXML.Schema.Compositor
private(set) var defines: [String: Pattern] = [:]
/// The combine method established for each define name (4.17): defines
/// sharing a name agree on one method, and the single define that omits
/// `combine` still merges by it.
private var defineCombine: [String: String] = [:]
private let loader: (String) -> String?
private var visited: Set<String> = []
/// The URI of the document currently being compiled (nil for the top
/// level): hrefs inside a loaded document resolve against it.
private var documentBase: String?
/// The `ns` value carried across a document boundary: an externalRef's
/// in-scope ns applies to the loaded pattern when it has none of its own
/// (simplification 4.6); the tree-ancestor walk cannot cross documents.
private var fallbackNamespace = ""
/// The start pattern contributed by an `include`d grammar (4.7), used when
/// the including grammar declares no start of its own.
private var includedStart: Pattern?
/// Each `grammar` element opens its own define scope; names are mangled
/// with the scope identifier so nested grammars do not collide and
/// `parentRef` reaches the enclosing grammar's scope.
private var scopeStack: [Int] = []
private var nextScope = 0
private func mangled(_ name: String) -> String {
"\(scopeStack.last ?? 0)\u{1}\(name)"
}
private func parentMangled(_ name: String) -> String {
let parent = scopeStack.count >= 2 ? scopeStack[scopeStack.count - 2] : (scopeStack.last ?? 0)
return "\(parent)\u{1}\(name)"
}
/// The ns in scope at a schema node: its own/ancestor `ns` attribute, or
/// the namespace inherited across the document boundary.
func effectiveNS(_ node: Tree) -> String {
RNGNode.inheritedNS(node) ?? fallbackNamespace
}
init(loader: @escaping (String) -> String?) {
self.loader = loader
}
func topLevel(_ node: Tree) -> Pattern {
RNGNode.localName(node) == "grammar" ? grammar(node) : pattern(node)
}
private func grammar(_ node: Tree) -> Pattern {
scopeStack.append(nextScope)
nextScope += 1
let outerIncludedStart = includedStart
includedStart = nil
defer {
scopeStack.removeLast()
includedStart = outerIncludedStart
}
for include in RNGNode.components(node, named: "include") {
mergeInclude(include)
}
for define in RNGNode.components(node, named: "define") {
addDefine(define)
}
let starts = RNGNode.components(node, named: "start")
guard let first = starts.first else {
return includedStart ?? .notAllowed
}
// Multiple starts combine like defines (4.17): the named method wins,
// and the single start that omits `combine` still merges by it.
var method: String?
for start in starts {
if let named = RNGNode.attribute(start, "combine") { method = named }
}
var result = combined(RNGNode.elementChildren(first), .sequence)
for start in starts.dropFirst() {
let next = combined(RNGNode.elementChildren(start), .sequence)
switch method {
case "choice": result = .choice(result, next)
case "interleave": result = .interleave(result, next)
default: result = next
}
}
return result
}
/// Adds a `define`, honoring `combine`: a second definition of the same name
/// with `combine="choice"`/`"interleave"` merges with the existing one rather
/// than replacing it (a plain redefinition still replaces).
private func addDefine(_ define: Tree) {
guard let rawName = RNGNode.attribute(define, "name") else { return }
let name = mangled(rawName)
let pattern = combined(RNGNode.elementChildren(define), .sequence)
if let method = RNGNode.attribute(define, "combine") {
defineCombine[name] = method
}
guard let existing = defines[name] else {
defines[name] = pattern
return
}
switch defineCombine[name] {
case "choice": defines[name] = .choice(existing, pattern)
case "interleave": defines[name] = .interleave(existing, pattern)
default: defines[name] = pattern
}
}
/// Merges an `include`d grammar: its `define`s first, then the `include`'s own
/// nested `define`s, which override or (with `combine`) merge with them.
private func mergeInclude(_ node: Tree) {
guard let href = RNGNode.resolvedHref(node, documentBase: documentBase), !visited.contains(href),
let text = loader(href), let root = try? PureXML.parseTree(text),
let grammar = RNGNode.elementChildren(root).first
else {
return
}
visited.insert(href)
let outerBase = documentBase
let outerNamespace = fallbackNamespace
documentBase = href
if RNGNode.inheritedNS(grammar) == nil {
fallbackNamespace = effectiveNS(node)
}
// The included grammar's own includes merge first (4.7 is transitive).
for nested in RNGNode.components(grammar, named: "include") {
mergeInclude(nested)
}
// A define carried by the include element REPLACES the included
// grammar's define of the same name (4.7 override), so those names
// are skipped here and added from the include's children below.
let overrides = Set(RNGNode.children(node, named: "define").compactMap { RNGNode.attribute($0, "name") })
for define in RNGNode.components(grammar, named: "define") {
guard let name = RNGNode.attribute(define, "name"), !overrides.contains(name) else { continue }
addDefine(define)
}
if includedStart == nil, let start = RNGNode.components(grammar, named: "start").first {
includedStart = combined(RNGNode.elementChildren(start), .sequence)
}
documentBase = outerBase
fallbackNamespace = outerNamespace
if let override = RNGNode.children(node, named: "start").first {
includedStart = combined(RNGNode.elementChildren(override), .sequence)
}
for define in RNGNode.children(node, named: "define") {
addDefine(define)
}
}
// MARK: Patterns
func pattern(_ node: Tree) -> Pattern {
leafPattern(node) ?? compositePattern(node)
}
private func leafPattern(_ node: Tree) -> Pattern? {
switch RNGNode.localName(node) {
case "empty": .empty
case "notAllowed": .notAllowed
case "text": .text
case "data": dataPattern(node)
case "value": valuePattern(node)
case "element": element(node)
case "attribute": attribute(node)
default: referencePattern(node)
}
}
/// The reference-shaped leaves: named refs (scope-mangled), parent refs,
/// nested grammars, and external references.
private func referencePattern(_ node: Tree) -> Pattern? {
switch RNGNode.localName(node) {
case "ref": .ref(mangled(RNGNode.attribute(node, "name") ?? ""))
case "parentRef": .ref(parentMangled(RNGNode.attribute(node, "name") ?? ""))
case "grammar": grammar(node)
case "externalRef": externalRef(node)
default: nil
}
}
/// The URI of the W3C XML Schema datatype library; the only non-default
/// library RELAX NG processors are required to support.
private static let xsdDatatypeLibrary = "http://www.w3.org/2001/XMLSchema-datatypes"
/// Builds a `<data type=>` pattern: its base built-in plus the facets its
/// `<param name= >value</param>` children constrain it with (the same facet
/// set the XSD datatypes use). A `type` that the in-scope `datatypeLibrary`
/// does not define is an unknown datatype, so the pattern matches nothing.
private func dataPattern(_ node: Tree) -> Pattern {
let typeName = RNGNode.strip(RNGNode.attribute(node, "type") ?? "string")
guard let base = resolvedBuiltin(typeName, library: datatypeLibrary(of: node)) else { return .notAllowed }
var facets = PureXML.Schema.Facets()
for param in RNGNode.children(node, named: "param") {
if let name = RNGNode.attribute(param, "name") {
PureXML.Schema.RelaxNGFacets.apply(name, RNGNode.text(param), into: &facets)
}
}
let type = PureXML.Schema.SimpleType(base: base, facets: facets)
// 4.12: an except child excludes its (implicitly choice-combined)
// patterns from the data type's lexical space.
if let except = RNGNode.children(node, named: "except").first {
return .dataExcept(type, combined(RNGNode.elementChildren(except), .choice))
}
return .data(type)
}
/// Builds a `<value>` pattern carrying its datatype, so the value compares in
/// that type's value space. An untyped `<value>` uses the built-in `token`
/// type; an explicit `type` the in-scope `datatypeLibrary` does not define is
/// an unknown datatype, so the value matches nothing.
private func valuePattern(_ node: Tree) -> Pattern {
guard let type = valueType(node) else { return .notAllowed }
if type.base == .qName {
// The QName value space: resolve the literal's prefix against the
// schema's xmlns scope; an unprefixed literal takes the in-scope
// ns attribute (6.2.9).
let raw = RNGNode.text(node)
if let qualified = RNGNode.resolveQName(raw, at: node) {
return .valueQName(namespace: qualified.namespace, localName: qualified.localName)
}
return .valueQName(namespace: effectiveNS(node), localName: raw)
}
return .value(type, RNGNode.rawText(node))
}
/// The datatype of a `<value>`: `token` when untyped, the library-resolved
/// built-in when typed, or nil when the declared type is unknown.
private func valueType(_ node: Tree) -> PureXML.Schema.SimpleType? {
guard let declared = RNGNode.attribute(node, "type") else {
return PureXML.Schema.SimpleType(base: .token)
}
guard let base = resolvedBuiltin(RNGNode.strip(declared), library: datatypeLibrary(of: node)) else {
return nil
}
return PureXML.Schema.SimpleType(base: base)
}
/// Resolves a datatype name within a library. The default (empty) library
/// defines only `string` and `token`; the XSD library defines every built-in;
/// any other library is unsupported, so its names are unknown.
private func resolvedBuiltin(_ typeName: String, library: String) -> PureXML.Schema.BuiltinType? {
switch library {
case "": typeName == "string" || typeName == "token" ? PureXML.Schema.BuiltinType(rawValue: typeName) : nil
case Self.xsdDatatypeLibrary: PureXML.Schema.BuiltinType(rawValue: typeName)
default: nil
}
}
/// The `datatypeLibrary` in scope at `node`: the nearest value on the node or
/// an ancestor, defaulting to the empty (RELAX NG built-in) library.
private func datatypeLibrary(of node: Tree) -> String {
var current: Tree? = node
while let candidate = current {
if let library = RNGNode.attribute(candidate, "datatypeLibrary") { return library }
current = candidate.parent
}
return ""
}
/// Resolves an `externalRef` to the referenced schema's pattern, merging any
/// grammar `define`s it carries into this compiler's table.
private func externalRef(_ node: Tree) -> Pattern {
guard let href = RNGNode.resolvedHref(node, documentBase: documentBase), !visited.contains(href),
let text = loader(href), let root = try? PureXML.parseTree(text),
let top = RNGNode.elementChildren(root).first
else {
return .notAllowed
}
visited.insert(href)
let outerBase = documentBase
let outerNamespace = fallbackNamespace
documentBase = href
if RNGNode.inheritedNS(top) == nil {
fallbackNamespace = effectiveNS(node)
}
defer {
documentBase = outerBase
fallbackNamespace = outerNamespace
}
return topLevel(top)
}
private func compositePattern(_ node: Tree) -> Pattern {
switch RNGNode.localName(node) {
case "group": combined(RNGNode.elementChildren(node), .sequence)
case "choice": combined(RNGNode.elementChildren(node), .choice)
case "interleave": combined(RNGNode.elementChildren(node), .all)
case "optional": .choice(group(node), .empty)
case "zeroOrMore": .choice(.oneOrMore(group(node)), .empty)
case "oneOrMore": .oneOrMore(group(node))
case "mixed": .interleave(group(node), .text)
case "list": .list(group(node))
default: .notAllowed
}
}
private func group(_ node: Tree) -> Pattern {
combined(RNGNode.elementChildren(node), .sequence)
}
private func element(_ node: Tree) -> Pattern {
let (nameClass, contentNodes) = nameClassAndContent(node)
return .element(nameClass, combined(contentNodes, .sequence))
}
private func attribute(_ node: Tree) -> Pattern {
let (nameClass, contentNodes) = nameClassAndContent(node)
let content = contentNodes.isEmpty ? Pattern.text : combined(contentNodes, .sequence)
return .attribute(nameClass, content)
}
}
extension PureXML.Schema {
/// Parses a RELAX NG schema in the XML syntax into a grammar: a start pattern
/// and the named `define` patterns it refers to. The vocabulary is matched by
/// local name. Supports `element`, `attribute`, `text`, `empty`, `notAllowed`,
/// `group`, `choice`, `interleave`, `optional`, `zeroOrMore`, `oneOrMore`,
/// `mixed`, `list`, `ref`, `data`, `value`, the name classes, and `include`
/// and `externalRef` resolved through `loader`.
enum RelaxNGParser {
static func parse(
_ rng: String,
loader: @escaping (String) -> String? = { _ in nil },
) throws -> (start: Pattern, defines: [String: Pattern]) {
let root = try PureXML.parseTree(rng)
guard let top = RNGNode.elementChildren(root).first else {
throw PureXML.Schema.SchemaError.notASchema
}
let compiler = RNGCompiler(loader: loader)
let start = compiler.topLevel(top)
return (start, compiler.defines)
}
}
}