PureXML/Sources/Schema/XSDSimpleParser.swift
Mihaela Mihaljevic aa7cbb71f8 feat(schema): validate value-bound facet definitions; accept gMonth --MM--
Continue the facet-validity work. Per XSD Part 2 Datatypes 4.3, each
minInclusive/maxInclusive/minExclusive/maxExclusive and enumeration value must
be a valid value of the base type; minInclusive excludes minExclusive and
maxInclusive excludes maxExclusive; and the lower bound may not exceed the upper
bound (nor equal it when either side is exclusive, an empty value space),
compared in the base primitive's value space. Bound and enumeration values were
previously unchecked, so a malformed or out-of-space value (maxInclusive="",
enumeration="" on float) was accepted.

The bound-value check (which validates a bound against its base type) exposed a
gMonth lexical gap: only --MM was recognized, not the XSD 1.0 form --MM-- used
by valid schemas across the corpus. parseMonthOnly now accepts an optional
trailing -- (the --MM erratum form still works), with an optional timezone,
which removes 26 false schema rejections the bound check would otherwise have
caused and also fixes instance-side gMonth validation.

XSTS: invalid schemas accepted 2082 to 1789; valid instances rejected 233 to
214 (the gMonth fix); valid schemas rejected held at 72; invalid instances
accepted held at 165.
2026-06-13 22:10:57 +02:00

238 lines
13 KiB
Swift

extension PureXML.Schema {
/// Parses XSD simple types: atomic restrictions with the full facet set, and
/// the `list` and `union` varieties. Kept beside ``XSDParser``, sharing its
/// module-scope tree helpers and parsing context.
enum XSDSimpleParser {
static func simpleType(_ node: XSDTree, _ context: XSDContext) -> SimpleType {
if let list = XSDNode.firstChild(node, named: "list") {
return listType(list, context)
}
if let union = XSDNode.firstChild(node, named: "union") {
return unionType(union, context)
}
guard let restriction = XSDNode.firstChild(node, named: "restriction") else {
return SimpleType(base: .string)
}
// Resolve the base through simpleTypeReference so the built-in list
// datatypes (NMTOKENS, IDREFS, ENTITIES) keep their list variety: a
// length facet on one of them counts list items, not characters (#146).
// Restricting a user type inherits its base, facets, and variety.
let baseType = simpleTypeReference(XSDNode.attribute(restriction, "base") ?? "string", context)
var facets = baseType.facets
// A restriction's own `enumeration` replaces the inherited set (the new
// enumeration is the value space, not a union with the base's), whereas
// `pattern` accumulates across steps and is ANDed. So drop the inherited
// enumeration when this step declares its own.
if XSDNode.elementChildren(restriction).contains(where: { XSDNode.localName($0) == "enumeration" }) {
facets.enumeration = nil
}
applyFacets(restriction, into: &facets)
for error in facetDefinitionErrors(restriction, base: baseType) {
context.diagnostics.report(error)
}
return SimpleType(base: baseType.base, facets: facets, variety: baseType.variety)
}
/// Schema-validity findings for the constraining facets declared on one
/// `restriction` (XSD Part 2 Datatypes 4.3): the length-family rules plus
/// the value-bound rules, both limited to the facets declared on this step
/// so an inherited facet is never flagged here.
static func facetDefinitionErrors(_ restriction: XSDTree, base: SimpleType) -> [String] {
countFacetErrors(restriction) + boundFacetErrors(restriction, base: base)
}
/// Length-family findings: `length`, `minLength`, `maxLength`,
/// `totalDigits`, and `fractionDigits` must be `nonNegativeInteger`
/// (`totalDigits` a `positiveInteger`), `length` may not co-occur with
/// `minLength`/`maxLength`, and `minLength` <= `maxLength`,
/// `fractionDigits` <= `totalDigits`. Reads the raw lexical, since numeric
/// facet parsing silently drops a malformed value.
private static func countFacetErrors(_ restriction: XSDTree) -> [String] {
var errors: [String] = []
var values: [String: String] = [:] // facet name -> canonical digit string
let countFacets: Set = ["length", "minLength", "maxLength", "totalDigits", "fractionDigits"]
for facet in XSDNode.elementChildren(restriction) {
guard let name = XSDNode.localName(facet), countFacets.contains(name) else { continue }
let raw = XSDNode.attribute(facet, "value")
guard let canonical = raw.flatMap(canonicalNonNegativeInteger) else {
errors.append("facet '\(name)' value '\(raw ?? "")' is not a valid nonNegativeInteger")
continue
}
if name == "totalDigits", canonical == "0" {
errors.append("facet 'totalDigits' value '\(raw ?? "")' must be a positiveInteger")
}
values[name] = canonical
}
if values["length"] != nil, values["minLength"] != nil {
errors.append("facets 'length' and 'minLength' may not both be specified")
}
if values["length"] != nil, values["maxLength"] != nil {
errors.append("facets 'length' and 'maxLength' may not both be specified")
}
if let low = values["minLength"], let high = values["maxLength"], greater(low, than: high) {
errors.append("facet 'minLength' (\(low)) exceeds 'maxLength' (\(high))")
}
if let fraction = values["fractionDigits"], let total = values["totalDigits"], greater(fraction, than: total) {
errors.append("facet 'fractionDigits' (\(fraction)) exceeds 'totalDigits' (\(total))")
}
return errors
}
/// Value-bound findings: each `minInclusive`/`maxInclusive`/`minExclusive`/
/// `maxExclusive` and `enumeration` value must be a valid value of the base
/// type; `minInclusive` excludes `minExclusive` and `maxInclusive` excludes
/// `maxExclusive`; and the lower bound may not exceed the upper bound (nor
/// equal it when either side is exclusive, which is an empty value space).
/// Ordering is compared in the base primitive's value space.
private static func boundFacetErrors(_ restriction: XSDTree, base: SimpleType) -> [String] {
var errors: [String] = []
var bounds: [String: String] = [:]
for facet in XSDNode.elementChildren(restriction) {
guard let name = XSDNode.localName(facet) else { continue }
let raw = XSDNode.attribute(facet, "value") ?? ""
switch name {
case "minInclusive", "maxInclusive", "minExclusive", "maxExclusive":
if base.validate(raw) != nil {
errors.append("facet '\(name)' value '\(raw)' is not a valid value of the base type")
} else {
bounds[name] = raw
}
case "enumeration":
if base.validate(raw) != nil {
errors.append("enumeration value '\(raw)' is not a valid value of the base type")
}
default:
break
}
}
if bounds["minInclusive"] != nil, bounds["minExclusive"] != nil {
errors.append("facets 'minInclusive' and 'minExclusive' may not both be specified")
}
if bounds["maxInclusive"] != nil, bounds["maxExclusive"] != nil {
errors.append("facets 'maxInclusive' and 'maxExclusive' may not both be specified")
}
errors += boundOrderErrors(bounds, base: base)
return errors
}
/// The lower-versus-upper-bound ordering finding, if any, comparing in the
/// base primitive's value space. Skipped for an unordered primitive (the
/// `ordered` lookup returns nil), so only a defined order is checked.
private static func boundOrderErrors(_ bounds: [String: String], base: SimpleType) -> [String] {
guard let low = bounds["minInclusive"] ?? bounds["minExclusive"],
let high = bounds["maxInclusive"] ?? bounds["maxExclusive"],
let lowValue = base.base.primitive.ordered(low),
let highValue = base.base.primitive.ordered(high)
else { return [] }
if lowValue > highValue {
return ["lower bound '\(low)' exceeds upper bound '\(high)'"]
}
let exclusive = bounds["minExclusive"] != nil || bounds["maxExclusive"] != nil
if lowValue == highValue, exclusive {
return ["bounds '\(low)' and '\(high)' describe an empty value space"]
}
return []
}
/// The canonical digit string of a lexical `nonNegativeInteger` (optional
/// leading `+`, ASCII digits, surrounding whitespace tolerated), with the
/// sign and leading zeros stripped (`"0"` for zero), or nil when the lexical
/// is not one (`-1`, ``, `a`, `1e2`). Independent of machine-integer range,
/// so a huge but well-formed value is canonicalized, not misreported as
/// malformed; the canonical form orders two values by length then lexically.
private static func canonicalNonNegativeInteger(_ lexical: String) -> String? {
var digits = Substring(lexical.trimmingXMLWhitespace())
if digits.first == "+" { digits = digits.dropFirst() }
guard !digits.isEmpty, digits.allSatisfy({ $0.isASCII && $0.isNumber }) else { return nil }
let trimmed = digits.drop { $0 == "0" }
return trimmed.isEmpty ? "0" : String(trimmed)
}
/// Whether canonical nonNegativeInteger `lhs` is greater than `rhs`: a longer
/// digit string is larger, and same-length strings compare lexicographically.
private static func greater(_ lhs: String, than rhs: String) -> Bool {
lhs.count != rhs.count ? lhs.count > rhs.count : lhs > rhs
}
static func simpleTypeReference(_ typeName: String, _ context: XSDContext) -> SimpleType {
let local = XSDNode.stripPrefix(typeName)
if let builtin = BuiltinType(rawValue: local) { return SimpleType(base: builtin) }
if let item = listBuiltinItem(local) { return .list(item: SimpleType(base: item)) }
return context.simpleTypes[local] ?? SimpleType(base: .string)
}
/// The item type of a built-in list datatype (`IDREFS`, `ENTITIES`,
/// `NMTOKENS`), each a whitespace-separated list of its singular form.
static func listBuiltinItem(_ name: String) -> BuiltinType? {
switch name {
case "IDREFS": .idref
case "ENTITIES": .entity
case "NMTOKENS": .nmtoken
default: nil
}
}
static func applyFacets(_ restriction: XSDTree, into facets: inout Facets) {
for facet in XSDNode.elementChildren(restriction) {
let value = XSDNode.attribute(facet, "value")
applyStringFacet(XSDNode.localName(facet), value, into: &facets)
applyNumericFacet(XSDNode.localName(facet), value, into: &facets)
}
}
private static func listType(_ node: XSDTree, _ context: XSDContext) -> SimpleType {
let item: SimpleType = if let itemType = XSDNode.attribute(node, "itemType") {
simpleTypeReference(itemType, context)
} else if let inline = XSDNode.firstChild(node, named: "simpleType") {
simpleType(inline, context)
} else {
SimpleType(base: .string)
}
return .list(item: item)
}
private static func unionType(_ node: XSDTree, _ context: XSDContext) -> SimpleType {
var members: [SimpleType] = []
if let names = XSDNode.attribute(node, "memberTypes") {
members += names.split(whereSeparator: \.isWhitespace).map { simpleTypeReference(String($0), context) }
}
members += XSDNode.children(node, named: "simpleType").map { simpleType($0, context) }
return .union(members)
}
private static func applyStringFacet(_ name: String?, _ value: String?, into facets: inout Facets) {
switch name {
case "pattern": if let value { facets.patterns.append(value) }
case "enumeration": if let value { facets.enumeration = (facets.enumeration ?? []) + [value] }
case "minInclusive": facets.minInclusive = value
case "maxInclusive": facets.maxInclusive = value
case "minExclusive": facets.minExclusive = value
case "maxExclusive": facets.maxExclusive = value
case "whiteSpace": facets.whiteSpace = whiteSpace(value)
default: break
}
}
private static func applyNumericFacet(_ name: String?, _ value: String?, into facets: inout Facets) {
let number = value.flatMap(Int.init)
switch name {
case "length": facets.length = number
case "minLength": facets.minLength = number
case "maxLength": facets.maxLength = number
case "totalDigits": facets.totalDigits = number
case "fractionDigits": facets.fractionDigits = number
default: break
}
}
private static func whiteSpace(_ value: String?) -> WhiteSpace? {
switch value {
case "preserve": .preserve
case "replace": .replace
case "collapse": .collapse
default: nil
}
}
}
}