Mihaela Mihaljevic
380160cc2b
The two monolithic XSD content/identity rules only satisfied the OpenAPIKit validation idiom at the wrong granularity: no per-constraint removability, no isolable failing/near-miss tests. Split them into 32 named rules, each finding tagged at its origin and cached per XSDContext so the walk still runs once per document (the #101 decision against duplicating XSD's recursive type resolution still holds). Wired the streaming path's ID/IDREF and identity checks through the same framework instead of calling the validators imperatively, and added the unwrapAndLookup combinator the rule already named as required. Also includes the mandated repo-wide swiftformat/swiftlint pass.
318 lines
14 KiB
Swift
318 lines
14 KiB
Swift
/// File-scope aliases for the complex-type validator's helpers, kept out of the
|
|
/// namespace to avoid nesting a type two levels deep in a dotted extension.
|
|
private typealias XSDTerm = PureXML.Schema.Term
|
|
private typealias XSDTermLabel = PureXML.Schema.TermLabel
|
|
private typealias XSDElementType = PureXML.Schema.ElementType
|
|
private typealias XSDWildcard = PureXML.Schema.Wildcard
|
|
|
|
extension PureXML.Schema.ComplexValidator {
|
|
// MARK: Helpers
|
|
|
|
/// The coding-path step for each child: its name, with a sibling index only
|
|
/// when more than one child shares that name.
|
|
static func childSteps(_ children: [PureXML.Model.Element]) -> [PureXML.Validation.PathKey] {
|
|
PureXML.Validation.PathKey.steps(forChildNames: children.map(\.name.description))
|
|
}
|
|
|
|
/// The `processContents` of a wildcard reachable in `term`, if the content
|
|
/// model contains one.
|
|
static func wildcard(in term: PureXML.Schema.Term) -> PureXML.Schema.ProcessContents? {
|
|
switch term {
|
|
case let .wildcard(wildcard):
|
|
return wildcard.processContents
|
|
case let .group(group):
|
|
for member in group.particles {
|
|
if let found = wildcard(in: member.term) {
|
|
return found
|
|
}
|
|
}
|
|
return nil
|
|
case .element:
|
|
return nil
|
|
}
|
|
}
|
|
|
|
static func elementTypes(in term: PureXML.Schema.Term) -> [String: PureXML.Schema.ElementType] {
|
|
var result: [String: XSDElementType] = [:]
|
|
collectTypes(term, into: &result)
|
|
return result
|
|
}
|
|
|
|
fileprivate static func collectTypes(_ term: XSDTerm, into result: inout [String: XSDElementType]) {
|
|
switch term {
|
|
case let .element(name, type, _, _, _, _):
|
|
if let type {
|
|
result[key(name)] = type
|
|
}
|
|
case let .group(group):
|
|
for member in group.particles {
|
|
collectTypes(member.term, into: &result)
|
|
}
|
|
case .wildcard:
|
|
break
|
|
}
|
|
}
|
|
|
|
/// The per-particle `default`/`fixed` value constraint of each named element in a
|
|
/// content model, keyed by namespaced identity. The streaming validator uses this
|
|
/// to apply a child's particle constraint (not the by-local-name `elementConstraints`
|
|
/// map, which collides across same-local-name elements in different types).
|
|
static func elementValueConstraints(in term: PureXML.Schema.Term) -> [String: PureXML.Schema.ValueConstraint] {
|
|
var result: [String: PureXML.Schema.ValueConstraint] = [:]
|
|
collectValueConstraints(term, into: &result)
|
|
return result
|
|
}
|
|
|
|
fileprivate static func collectValueConstraints(_ term: XSDTerm, into result: inout [String: PureXML.Schema.ValueConstraint]) {
|
|
switch term {
|
|
case let .element(name, _, _, valueConstraint, _, _):
|
|
if let valueConstraint {
|
|
result[key(name)] = valueConstraint
|
|
}
|
|
case let .group(group):
|
|
for member in group.particles {
|
|
collectValueConstraints(member.term, into: &result)
|
|
}
|
|
case .wildcard:
|
|
break
|
|
}
|
|
}
|
|
|
|
static func key(_ name: PureXML.Model.QualifiedName) -> String {
|
|
"{\(name.namespaceURI ?? "")}\(name.localName)"
|
|
}
|
|
|
|
/// Whether two names match by namespace and local name. Used to match an
|
|
/// instance attribute against a declared attribute use, so attributes that
|
|
/// share a local name in different namespaces are kept distinct.
|
|
static func sameName(_ lhs: PureXML.Model.QualifiedName, _ rhs: PureXML.Model.QualifiedName) -> Bool {
|
|
lhs.namespaceURI == rhs.namespaceURI && lhs.localName == rhs.localName
|
|
}
|
|
|
|
/// Namespace prefix bindings declared on an element (`xmlns`, `xmlns:p`).
|
|
static func namespaceBindingsDeclared(on element: PureXML.Model.Element) -> [String: String] {
|
|
var bindings: [String: String] = [:]
|
|
for attribute in element.attributes {
|
|
if attribute.name.prefix == "xmlns" {
|
|
bindings[attribute.name.localName] = attribute.value
|
|
} else if attribute.name.prefix == nil, attribute.name.localName == "xmlns" {
|
|
bindings[""] = attribute.value
|
|
}
|
|
}
|
|
return bindings
|
|
}
|
|
|
|
/// In-scope prefix bindings for `element`, merging ancestor declarations.
|
|
static func namespaceBindings(for element: PureXML.Model.Element, inherited: [String: String] = [:]) -> [String: String] {
|
|
inherited.merging(namespaceBindingsDeclared(on: element)) { _, new in new }
|
|
}
|
|
|
|
/// The lexical `xsi:type` attribute value, when present.
|
|
static func xsiTypeAttributeValue(_ element: PureXML.Model.Element) -> String? {
|
|
let schemaInstance = "http://www.w3.org/2001/XMLSchema-instance"
|
|
let match = element.attributes.first { attribute in
|
|
attribute.name.localName == "type"
|
|
&& (attribute.name.namespaceURI == schemaInstance || attribute.name.prefix == "xsi")
|
|
}
|
|
return match?.value.trimmingXMLWhitespace()
|
|
}
|
|
|
|
/// Resolves an instance `xsi:type` attribute to a named type-table key. The
|
|
/// value is a QName resolved in the instance's namespace context: a prefix
|
|
/// binds through that prefix, an unprefixed name through the in-scope default
|
|
/// namespace. With no default namespace an unprefixed name is in no namespace,
|
|
/// so it keys against the no-namespace type, NOT a namespaced type of the same
|
|
/// local name (XSTS targetNS00101m: `xsi:type="Test"` with no default namespace
|
|
/// does not name `{targetNS}Test`).
|
|
static func xsiTypeReference(_ element: PureXML.Model.Element, namespaceBindings: [String: String]) -> String? {
|
|
guard let value = xsiTypeAttributeValue(element) else { return nil }
|
|
let local = value.split(separator: ":").last.map(String.init) ?? value
|
|
if value.contains(":"), let prefix = value.split(separator: ":", maxSplits: 1).first.map(String.init), let uri = namespaceBindings[prefix] {
|
|
return PureXML.Schema.XSDParser.typeDeclarationKey(local, namespaceURI: uri)
|
|
}
|
|
return PureXML.Schema.XSDParser.typeDeclarationKey(local, namespaceURI: namespaceBindings[""])
|
|
}
|
|
|
|
/// The element's character content, trimmed: used to decide whether an
|
|
/// element-only or empty type wrongly carries significant text (indentation
|
|
/// whitespace between child elements is not significant).
|
|
static func textContent(_ element: PureXML.Model.Element) -> String {
|
|
rawTextContent(element).trimmingXMLWhitespace()
|
|
}
|
|
|
|
/// The element's character content verbatim. Simple-content validation uses
|
|
/// this so the type's own `whiteSpace` facet decides normalization: a
|
|
/// `preserve` type (xs:string) keeps leading/trailing whitespace, while a
|
|
/// `collapse` type still trims and collapses through `process`.
|
|
static func rawTextContent(_ element: PureXML.Model.Element) -> String {
|
|
element.children.reduce(into: "") { result, child in
|
|
switch child {
|
|
case let .text(value), let .cdata(value): result += value
|
|
default: break
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Whether `complex` is the ur-type `xsd:anyType`: no declared attributes, a
|
|
/// `lax` attribute wildcard, and mixed content of a single unbounded `lax`
|
|
/// element wildcard (XSD 1.0 §3.4.7). The ur-type admits any `xsi:type`
|
|
/// substitution. A `skip` wildcard is also accepted so any legacy construction
|
|
/// of the ur-type still reads as the ur-type.
|
|
static func isUrType(_ complex: PureXML.Schema.ComplexType) -> Bool {
|
|
guard complex.attributes.isEmpty,
|
|
complex.attributeWildcard?.processContents != .strict,
|
|
case let .mixed(particle) = complex.content,
|
|
particle.minOccurs == 0, particle.maxOccurs == nil,
|
|
case let .wildcard(wildcard) = particle.term,
|
|
wildcard.processContents != .strict
|
|
else { return false }
|
|
return true
|
|
}
|
|
|
|
static func isNamespaceDeclaration(_ attribute: PureXML.Model.Attribute) -> Bool {
|
|
attribute.name.prefix == "xmlns" || (attribute.name.prefix == nil && attribute.name.localName == "xmlns")
|
|
}
|
|
|
|
/// Whether an attribute belongs to the XML Schema instance namespace
|
|
/// (`xsi:type`, `xsi:nil`, and the schema-location hints), which are
|
|
/// processing directives rather than declared attributes.
|
|
static func isSchemaInstanceAttribute(_ attribute: PureXML.Model.Attribute) -> Bool {
|
|
attribute.name.namespaceURI == "http://www.w3.org/2001/XMLSchema-instance" || attribute.name.prefix == "xsi"
|
|
}
|
|
|
|
/// The local name of an element's `xsi:type` attribute value, or nil when it
|
|
/// carries none. Recognizes the attribute by the XML Schema instance
|
|
/// namespace or, failing namespace resolution, the conventional `xsi` prefix.
|
|
static func xsiTypeName(_ element: PureXML.Model.Element) -> String? {
|
|
xsiTypeAttributeValue(element).map { $0.split(separator: ":").last.map(String.init) ?? $0 }
|
|
}
|
|
}
|
|
|
|
extension PureXML.Schema.ComplexValidator {
|
|
/// Whether the element carries `xsi:nil="true"`.
|
|
static func isNil(_ element: PureXML.Model.Element) -> Bool {
|
|
nilAttributeValue(element) == "true"
|
|
}
|
|
|
|
/// The value of the `xsi:nil` attribute if present (any value), or nil if the
|
|
/// element carries no `xsi:nil`. Used for the cvc-elt.3.1 rule that a
|
|
/// non-nillable element must carry no `xsi:nil` attribute at all.
|
|
static func nilAttributeValue(_ element: PureXML.Model.Element) -> String? {
|
|
element.attributes.first { attribute in
|
|
attribute.name.localName == "nil"
|
|
&& (attribute.name.namespaceURI == "http://www.w3.org/2001/XMLSchema-instance" || attribute.name.prefix == "xsi")
|
|
}?.value
|
|
}
|
|
|
|
/// Whether the element has any child element or non-whitespace text.
|
|
static func hasContent(_ element: PureXML.Model.Element) -> Bool {
|
|
!textContent(element).isEmpty || element.children.contains {
|
|
if case .element = $0 {
|
|
true
|
|
} else {
|
|
false
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public extension PureXML.Schema {
|
|
/// The outcome of following a `typeReference` chain: the underlying simple or
|
|
/// complex type, or the failure to report (an unknown name, or a circular
|
|
/// chain that can never resolve).
|
|
enum TypeResolution {
|
|
case resolved(ElementType)
|
|
case unknown(String)
|
|
case circular(String)
|
|
}
|
|
}
|
|
|
|
extension PureXML.Schema.ComplexValidator {
|
|
/// Follows a `typeReference` chain through `types` with cycle detection, the
|
|
/// one shared resolver behind the tree validator, the streaming validator, and
|
|
/// completions, so unknown names and circular chains are reported identically
|
|
/// everywhere instead of being silently truncated.
|
|
static func resolveReference(
|
|
_ type: PureXML.Schema.ElementType,
|
|
in types: [String: PureXML.Schema.ElementType],
|
|
) -> PureXML.Schema.TypeResolution {
|
|
var current = type
|
|
var visited: Set<String> = []
|
|
while case let .typeReference(name) = current {
|
|
guard visited.insert(name).inserted else { return .circular(name) }
|
|
guard let next = resolveNamedType(name, in: types) else { return .unknown(name) }
|
|
current = next
|
|
}
|
|
return .resolved(current)
|
|
}
|
|
|
|
/// Resolves a named type reference, including built-in datatypes and ur-types.
|
|
static func resolveNamedType(_ name: String, in types: [String: PureXML.Schema.ElementType]) -> PureXML.Schema.ElementType? {
|
|
if let next = types[name] {
|
|
return next
|
|
}
|
|
if name.hasPrefix("type:"), let (uri, local) = parseQualifiedTypeKey(name) {
|
|
if uri == PureXML.Schema.XSDParser.xsdNamespace, let builtin = urOrBuiltinType(named: local) {
|
|
return builtin
|
|
}
|
|
if let next = types[PureXML.Schema.XSDParser.typeDeclarationKey(local, namespaceURI: uri)] {
|
|
return next
|
|
}
|
|
}
|
|
if !name.hasPrefix("type:"), let next = types[PureXML.Schema.XSDParser.typeDeclarationKey(name, namespaceURI: nil)] {
|
|
return next
|
|
}
|
|
if let builtin = PureXML.Schema.BuiltinType(rawValue: name) {
|
|
return .simple(PureXML.Schema.SimpleType(base: builtin))
|
|
}
|
|
if name == "anySimpleType" {
|
|
return .simple(PureXML.Schema.SimpleType(base: .string, isAnySimpleType: true))
|
|
}
|
|
if name == "anyType" {
|
|
return .complex(Self.urComplexType)
|
|
}
|
|
if let item = PureXML.Schema.XSDSimpleParser.listBuiltinItem(name) {
|
|
return .simple(.list(item: PureXML.Schema.SimpleType(base: item), isBuiltinList: true))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
private static func parseQualifiedTypeKey(_ name: String) -> (uri: String, local: String)? {
|
|
let keyBody = String(name.dropFirst("type:".count))
|
|
guard keyBody.hasPrefix("{"), let close = keyBody.firstIndex(of: "}") else { return nil }
|
|
let uri = String(keyBody[keyBody.index(after: keyBody.startIndex) ..< close])
|
|
let local = String(keyBody[keyBody.index(after: close)...])
|
|
return (uri, local)
|
|
}
|
|
|
|
private static func urOrBuiltinType(named local: String) -> PureXML.Schema.ElementType? {
|
|
if let builtin = PureXML.Schema.BuiltinType(rawValue: local) {
|
|
return .simple(PureXML.Schema.SimpleType(base: builtin))
|
|
}
|
|
if local == "anySimpleType" {
|
|
return .simple(PureXML.Schema.SimpleType(base: .string, isAnySimpleType: true))
|
|
}
|
|
if local == "anyType" {
|
|
return .complex(urComplexType)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
/// The ur-type `xsd:anyType`. Per XSD 1.0 §3.4.7 its element and attribute
|
|
/// wildcards are `lax` (not skip): declared children and attributes are
|
|
/// validated against their global declarations, undeclared content is admitted.
|
|
static let urComplexType = PureXML.Schema.ComplexType(
|
|
attributeWildcard: PureXML.Schema.Wildcard(processContents: .lax),
|
|
content: .mixed(PureXML.Schema.Particle(
|
|
minOccurs: 0,
|
|
maxOccurs: nil,
|
|
term: .wildcard(PureXML.Schema.Wildcard(processContents: .lax)),
|
|
)),
|
|
)
|
|
|
|
/// The instance resolver over this validator's type table.
|
|
func resolveReference(_ type: PureXML.Schema.ElementType) -> PureXML.Schema.TypeResolution {
|
|
Self.resolveReference(type, in: types)
|
|
}
|
|
}
|