PureXML/Sources/Validation/DTDValidations.swift
Mihaela Mihaljevic 89cb299201 feat(validation): DTD declaration-level validity constraints
VC Root Element Type (root matches the DOCTYPE name), VC Unique
Element Type Declaration, VC No Duplicate Types in mixed content, VC
One ID per Element Type, VC Notation Attributes and Notation Declared,
VC Attribute Default Legal plus ID Attribute Default, lexical Name
checks for the ID family, and CDATA as character data in element
content. Strict mode adds VC Attribute Value Type (every attribute
declared; namespace declarations exempt). Declaration findings are
computed once at schema build and reported at the document root. Sun
invalid coverage moves from 43/74 to 62/74; the twelve remaining are
all the standalone='yes' family.
2026-06-10 07:05:14 +02:00

161 lines
8.5 KiB
Swift

/// File-scope aliases for the DTD validation rules and helpers, kept out of the
/// `DTD` enum to avoid nesting a type two levels deep.
typealias DTDElement = PureXML.Model.Element
typealias DTDPath = [PureXML.Validation.PathKey]
typealias DTDFailure = PureXML.Validation.ValidationError
public extension PureXML.Validation {
/// DTD validation as composable rules over a ``DTDSchema`` document: every
/// element is checked against its content model and attribute declarations,
/// and ID/IDREF integrity is checked once over the whole tree. Replaces the
/// imperative walk with declared ``Validation`` values.
enum DTD {
/// A validator for a ``DTDSchema``. In strict mode every element must also
/// be declared.
static func validator(strict: Bool) -> Validator<DTDSchema> {
var validator = Validator<DTDSchema>.blank
.validating(contentModel)
.validating(requiredAttributes, fixedAttributeValues, enumeratedAttributeValues)
.validating(tokenizedAttributeTypes, notationAttributes)
.validating(identifierIntegrity)
.validating(declarationValidity, rootElementType)
if strict { validator = validator.validating(undeclaredElement, undeclaredAttributes) }
return validator
}
/// Each element's content matches its `<!ELEMENT>` model.
static var contentModel: Validation<DTDElement, DTDSchema> {
.init(description: "Element content matches its DTD content model") { context in
let element = context.subject
guard let model = context.document.models[element.name.description] else { return [] }
return contentViolations(element, model: model, at: context.codingPath)
}
}
/// Every `#REQUIRED` attribute declared for an element is present.
static var requiredAttributes: Validation<DTDElement, DTDSchema> {
attributeRule("Required DTD attributes are present") { declaration, element, path in
requiredViolation(declaration, on: element, at: path)
}
}
/// Every `#FIXED` attribute, when present, holds its fixed value.
static var fixedAttributeValues: Validation<DTDElement, DTDSchema> {
attributeRule("#FIXED DTD attributes hold their fixed value") { declaration, element, path in
fixedViolation(declaration, on: element, at: path)
}
}
/// Every enumerated attribute, when present, holds a value from its list.
static var enumeratedAttributeValues: Validation<DTDElement, DTDSchema> {
attributeRule("Enumerated DTD attributes hold a listed value") { declaration, element, path in
enumerationViolation(declaration, on: element, at: path)
}
}
/// Every tokenized attribute (`NMTOKEN(S)`, `ENTITY`/`ENTITIES`), when
/// present, matches its declared lexical form.
static var tokenizedAttributeTypes: Validation<DTDElement, DTDSchema> {
.init(description: "Tokenized DTD attributes match their declared type") { context in
let element = context.subject
let schema = context.document
return (schema.attributes[element.name.description] ?? []).compactMap { declaration in
attributeValue(of: declaration, on: element).flatMap { value in
tokenizedTypeError(declaration, value: value, on: element.name.description, entities: schema.unparsedEntities, at: context.codingPath)
}
}
}
}
/// Every `NOTATION` attribute, when present, names a declared, listed
/// notation.
static var notationAttributes: Validation<DTDElement, DTDSchema> {
.init(description: "NOTATION DTD attributes name a declared notation") { context in
let element = context.subject
let schema = context.document
return (schema.attributes[element.name.description] ?? []).compactMap { declaration in
attributeValue(of: declaration, on: element).flatMap { value in
notationError(declaration, value: value, on: element.name.description, notations: schema.notations, at: context.codingPath)
}
}
}
}
/// Builds a per-declaration attribute rule: the `check` is applied to each
/// `<!ATTLIST>` declaration for the element, gathering one failure each.
private static func attributeRule(
_ description: String,
_ check: @escaping (PureXML.Validation.AttributeDeclaration, DTDElement, DTDPath) -> DTDFailure?,
) -> Validation<DTDElement, DTDSchema> {
.init(description: description) { context in
let element = context.subject
return (context.document.attributes[element.name.description] ?? []).compactMap { check($0, element, context.codingPath) }
}
}
/// In strict mode, every element is declared in the DTD.
static var undeclaredElement: Validation<DTDElement, DTDSchema> {
.init(description: "Element is declared in the DTD") { context in
context.document.models[context.subject.name.description] != nil
}
}
/// In strict mode, every attribute is declared (VC: Attribute Value
/// Type). Namespace declarations are exempt: they are bindings, not
/// attributes, in the namespace-aware model.
static var undeclaredAttributes: Validation<DTDElement, DTDSchema> {
.init(description: "Every attribute is declared in the DTD") { context in
let element = context.subject
let declarations = context.document.attributes[element.name.description] ?? []
return element.attributes
.filter { attribute in
let name = attribute.name.description
guard name != "xmlns", !name.hasPrefix("xmlns:") else { return false }
return !declarations.contains { $0.name == name || $0.name == attribute.name.localName }
}
.map { DTDFailure(reason: "attribute '\($0.name.description)' on <\(element.name.description)> is not declared", at: context.codingPath) }
}
}
/// The DTD's own declarations are valid (duplicate element types,
/// repeated mixed names, multiple IDs, undeclared notations in lists,
/// illegal defaults). Reported once, at the document root.
static var declarationValidity: Validation<PureXML.Model.Node, DTDSchema> {
.init(
description: "The DTD declarations satisfy their validity constraints",
check: { context in
context.document.declarationErrors.map { DTDFailure(reason: $0, at: context.codingPath) }
},
when: { $0.codingPath.isEmpty },
)
}
/// The root element's type matches the DOCTYPE name (VC: Root Element
/// Type). Reported once, at the document root.
static var rootElementType: Validation<PureXML.Model.Node, DTDSchema> {
.init(
description: "The root element matches the DOCTYPE name",
check: { context in
guard let expected = context.document.doctypeName,
case let .document(children) = context.subject,
let root = children.compactMap(\.element).first,
root.name.description != expected
else { return [] }
return [DTDFailure(reason: "root element <\(root.name.description)> does not match the DOCTYPE name '\(expected)'", at: context.codingPath)]
},
when: { $0.codingPath.isEmpty },
)
}
/// ID values are unique and every IDREF resolves. Runs once over the whole
/// tree (a reference may point forward), so it is gated to the root.
static var identifierIntegrity: Validation<PureXML.Model.Node, DTDSchema> {
.init(
description: "DTD ID values are unique and IDREFs resolve",
check: { context in identifierErrors(context.subject, schema: context.document, at: context.codingPath) },
when: { $0.codingPath.isEmpty },
)
}
}
}