The namespaced derivation backbone keyed every element by the container target
namespace, but a local element is in the target namespace only when qualified (its
own form, else the schema's elementFormDefault). An unqualified local element's
block was keyed {targetNS}name while the instance element is {}name, so
blockedSubstitutionError's lookup missed and a blocked xsi:type substitution on it
was accepted (typeDef00801: a local Element with block="extension" did not bar an
extension substitution).
gatherElement now keys a local element by localElementNamespace (target namespace
when qualified, none otherwise); global elements stay keyed by the target
namespace, and the bare-keyed tables are unchanged.
invalid-instances-accepted 32 to 31, no false positive (valid-instances-rejected
and valid-schemas-rejected held at 0). An adversarial review confirmed qualified
local elements are unchanged, global and same-named local element keys stay
distinct, and a non-blocked substitution on a local element is still accepted.
137 lines
7.8 KiB
Swift
137 lines
7.8 KiB
Swift
private typealias XSDDerivNode = PureXML.Schema.XSDNode
|
|
|
|
extension PureXML.Schema.XSDParser {
|
|
/// Gathers the derivation-control facts (``DerivationTables``) from a schema's
|
|
/// definition containers, building both the bare-keyed tables (for the
|
|
/// schema-consistency machinery) and the namespaced (`{ns}local`) tables (for
|
|
/// the instance-validity subsystem) in one pass, resolving each container's
|
|
/// components through its target namespace and prefix bindings.
|
|
static func derivationTables(_ containers: [XSDTree], mainTargetNamespace: String?) -> DerivationTables {
|
|
var tables = DerivationTables()
|
|
let namespaceMap = resolveContainerNamespaces(containers, mainTargetNamespace: mainTargetNamespace)
|
|
for index in containers.indices {
|
|
let container = containers[index]
|
|
let containerNamespace = namespaceMap[index] ?? mainTargetNamespace
|
|
for type in descendants(container, named: "complexType") {
|
|
gatherType(type, in: containerNamespace, into: &tables)
|
|
}
|
|
for type in descendants(container, named: "simpleType") {
|
|
gatherSimpleType(type, in: containerNamespace, into: &tables)
|
|
}
|
|
for element in descendants(container, named: "element") {
|
|
gatherElement(element, in: containerNamespace, into: &tables)
|
|
}
|
|
}
|
|
return tables
|
|
}
|
|
|
|
/// The namespaced derivation-table key (`{ns}local`) for a component named
|
|
/// `local` in `namespace`, matching ``ComplexValidator/key(_:)``.
|
|
static func derivationKey(_ local: String, in namespace: String?) -> String {
|
|
PureXML.Schema.ComplexValidator.key(PureXML.Model.QualifiedName(localName: local, namespaceURI: namespace))
|
|
}
|
|
|
|
/// The namespaced key a base/type QName resolves to, given `node`'s in-scope
|
|
/// prefix bindings. A prefixed QName uses its prefix's binding; an unprefixed
|
|
/// QName the default-namespace binding when declared, else the component's own
|
|
/// target namespace.
|
|
private static func resolvedKey(of qualified: String, on node: XSDTree, default containerNamespace: String?) -> String {
|
|
let bindings = namespaceBindingsInScope(of: node, defaultBindings: [:])
|
|
let resolved = XSDDerivNode.prefix(qualified) != nil
|
|
? XSDDerivNode.referenceNamespace(qualified, bindings)
|
|
: (bindings[""] ?? containerNamespace)
|
|
return derivationKey(XSDDerivNode.stripPrefix(qualified), in: resolved)
|
|
}
|
|
|
|
/// Records a named `simpleType`'s restriction derivation and `final` controls.
|
|
/// A `simpleType` derives from its `restriction`'s `base`; a `list`/`union`
|
|
/// constructs a new type (deriving from `anySimpleType`), so it is left
|
|
/// unrecorded, which keeps two independent list/union types correctly
|
|
/// non-derivable from one another.
|
|
private static func gatherSimpleType(_ type: XSDTree, in namespace: String?, into tables: inout DerivationTables) {
|
|
guard let name = XSDDerivNode.attribute(type, "name") else { return }
|
|
let finalSet = methodSet(XSDDerivNode.attribute(type, "final"))
|
|
if !finalSet.isEmpty { tables.typeFinal[name] = finalSet }
|
|
guard let restriction = XSDDerivNode.firstChild(type, named: "restriction"),
|
|
let base = XSDDerivNode.attribute(restriction, "base") else { return }
|
|
tables.typeDerivation[name] = PureXML.Schema.TypeDerivation(base: XSDDerivNode.stripPrefix(base), method: .restriction)
|
|
tables.nsTypeDerivation[derivationKey(name, in: namespace)] = PureXML.Schema.TypeDerivation(
|
|
base: resolvedKey(of: base, on: type, default: namespace),
|
|
method: .restriction,
|
|
)
|
|
}
|
|
|
|
private static func gatherType(_ type: XSDTree, in namespace: String?, into tables: inout DerivationTables) {
|
|
guard let name = XSDDerivNode.attribute(type, "name") else { return }
|
|
let key = derivationKey(name, in: namespace)
|
|
if XSDDerivNode.attribute(type, "abstract") == "true" {
|
|
tables.abstractTypes.insert(name)
|
|
tables.nsAbstractTypes.insert(key)
|
|
}
|
|
let block = blockMethods(of: type, admitting: [.extension, .restriction])
|
|
if !block.isEmpty {
|
|
tables.typeBlock[name] = block
|
|
tables.nsTypeBlock[key] = block
|
|
}
|
|
let finalSet = finalMethods(of: type)
|
|
if !finalSet.isEmpty { tables.typeFinal[name] = finalSet }
|
|
if let derivation = derivationInfo(type) { tables.typeDerivation[name] = derivation }
|
|
if let derivation = namespacedDerivationInfo(type, in: namespace) { tables.nsTypeDerivation[key] = derivation }
|
|
}
|
|
|
|
private static func gatherElement(_ element: XSDTree, in namespace: String?, into tables: inout DerivationTables) {
|
|
guard let name = XSDDerivNode.attribute(element, "name") else { return }
|
|
let isGlobal = element.parent.map {
|
|
$0.name?.namespaceURI == xsdNamespace && XSDDerivNode.localName($0) == "schema"
|
|
} ?? false
|
|
// A global element is always in the target namespace; a local element is in
|
|
// it only when qualified (its `form`, else the schema's elementFormDefault),
|
|
// so its namespaced key matches the instance element's qualified name.
|
|
let elementNamespace = isGlobal ? namespace : localElementNamespace(element, in: namespace)
|
|
let key = derivationKey(name, in: elementNamespace)
|
|
if XSDDerivNode.attribute(element, "abstract") == "true" { tables.abstractElements.insert(name) }
|
|
let block = blockMethods(of: element, admitting: [.extension, .restriction, .substitution])
|
|
if !block.isEmpty {
|
|
tables.elementBlock[name] = block
|
|
tables.nsElementBlock[key] = block
|
|
}
|
|
if isGlobal {
|
|
let finalSet = finalMethods(of: element)
|
|
if !finalSet.isEmpty { tables.elementFinal[name] = finalSet }
|
|
}
|
|
if let type = XSDDerivNode.attribute(element, "type") {
|
|
tables.elementTypeNames[name] = XSDDerivNode.stripPrefix(type)
|
|
tables.nsElementTypeNames[key] = resolvedKey(of: type, on: element, default: namespace)
|
|
}
|
|
}
|
|
|
|
/// The namespace a local element's name takes at instance level: the target
|
|
/// namespace when the element is qualified (its own `form`, else the schema's
|
|
/// `elementFormDefault`), otherwise no namespace.
|
|
private static func localElementNamespace(_ element: XSDTree, in namespace: String?) -> String? {
|
|
switch XSDDerivNode.attribute(element, "form") {
|
|
case "qualified": return namespace
|
|
case "unqualified": return nil
|
|
default:
|
|
let schema = XSDDerivNode.schemaOwner(element)
|
|
return XSDDerivNode.attribute(schema, "elementFormDefault") == "qualified" ? namespace : nil
|
|
}
|
|
}
|
|
|
|
/// The namespaced (`{ns}local`-based) derivation backbone of a complex type:
|
|
/// the same `complexContent`/`simpleContent` extension/restriction base as
|
|
/// ``derivationInfo(_:)``, but with the base resolved to a namespaced key.
|
|
private static func namespacedDerivationInfo(_ type: XSDTree, in namespace: String?) -> PureXML.Schema.TypeDerivation? {
|
|
let container = XSDDerivNode.firstChild(type, named: "complexContent")
|
|
?? XSDDerivNode.firstChild(type, named: "simpleContent")
|
|
guard let container else { return nil }
|
|
if let ext = XSDDerivNode.firstChild(container, named: "extension"), let base = XSDDerivNode.attribute(ext, "base") {
|
|
return PureXML.Schema.TypeDerivation(base: resolvedKey(of: base, on: type, default: namespace), method: .extension)
|
|
}
|
|
if let res = XSDDerivNode.firstChild(container, named: "restriction"), let base = XSDDerivNode.attribute(res, "base") {
|
|
return PureXML.Schema.TypeDerivation(base: resolvedKey(of: base, on: type, default: namespace), method: .restriction)
|
|
}
|
|
return nil
|
|
}
|
|
}
|