From 25d851cc671b5fd5c341963f8ff9fb1ae64f4338 Mon Sep 17 00:00:00 2001 From: Lilleman auf Larv Date: Mon, 14 Sep 2026 16:54:32 +0200 Subject: [PATCH] 11b: guard the gate against empty gaps and unread keywords --- src/adf-schema.test.ts | 42 ++++++++++++++++++++++++++++-------------- 1 file changed, 28 insertions(+), 14 deletions(-) diff --git a/src/adf-schema.test.ts b/src/adf-schema.test.ts index 339d5d8..742f24b 100644 --- a/src/adf-schema.test.ts +++ b/src/adf-schema.test.ts @@ -18,8 +18,9 @@ type Spelled = [string, Map] const carried = ['alignment', 'annotation', 'backgroundColor', 'blockCard', 'bodiedRule', 'breakout', 'dataConsumer', 'embedCard', 'fontSize', 'fragment', 'indentation', 'inlineExtension', 'placeholder'] const definitionReference = '#/definitions/' -const gaps = new Map(Object.entries({ layoutSection: ['columnRuleStyle'], link: ['collection', 'id', 'occurrenceKey'], rule: ['color', 'style', 'weight'] })) +const gaps = ['layoutSection.columnRuleStyle', 'link.collection', 'link.id', 'link.occurrenceKey', 'rule.color', 'rule.style', 'rule.weight'] const grammarOwn = ['doc', 'text'] +const readKeywords = ['$ref', 'additionalProperties', 'allOf', 'anyOf', 'enum', 'items', 'maxItems', 'maximum', 'minItems', 'minLength', 'minimum', 'pattern', 'properties', 'required', 'type'] const root = join(dirname(fileURLToPath(import.meta.url)), '..', 'spec', 'adf-schema') const schemaFiles = ['full.json', 'stage-0.json'] @@ -33,25 +34,31 @@ test('the tables spell the attribute names and kinds the ADF JSON Schemas give e const held = schemaTypes() const spelledTypes = spelled() const found: string[] = [] + const gapsHeld = new Set() for (const [type, spelledKinds] of spelledTypes) { const kinds = held.get(type) if (kinds === undefined) { found.push(`${type}: the tables spell the type, the schema holds no definition of it`) continue } - const pinned = gaps.get(type) ?? [] for (const [attribute, schemaKinds] of kinds) { const kind = spelledKinds.get(attribute) const holds = [...schemaKinds].sort().join(' or ') - if (kind === undefined && !pinned.includes(attribute)) found.push(`${type}.${attribute}: the schema holds ${holds}, the tables spell nothing and the gaps list does not name it`) - if (kind !== undefined && pinned.includes(attribute)) found.push(`${type}.${attribute}: the tables spell ${kind}, and the gaps list still names it`) - if (kind !== undefined && (schemaKinds.size !== 1 || !schemaKinds.has(kind))) found.push(`${type}.${attribute}: the tables spell ${kind}, the schema holds ${holds}`) + if (kind === undefined && gaps.includes(`${type}.${attribute}`)) gapsHeld.add(`${type}.${attribute}`) + else if (kind === undefined) found.push(`${type}.${attribute}: the schema holds ${holds}, the tables spell nothing and the gaps list does not name it`) + else if (schemaKinds.size !== 1 || !schemaKinds.has(kind)) found.push(`${type}.${attribute}: the tables spell ${kind}, the schema holds ${holds}`) } for (const [attribute, kind] of spelledKinds) if (!kinds.has(attribute)) found.push(`${type}.${attribute}: the tables spell ${kind}, the schema holds nothing`) - for (const attribute of pinned) if (!kinds.has(attribute)) found.push(`${type}.${attribute}: the gaps list names it, the schema holds nothing`) } - const spelledNames = new Set(spelledTypes.map(([type]) => type)) - for (const type of gaps.keys()) if (!spelledNames.has(type)) found.push(`${type}: the gaps list names the type, the tables spell none of it`) + for (const gap of gaps) { + if (gapsHeld.has(gap)) continue + const [type = '', attribute = ''] = gap.split('.') + const spelledKinds = spelledTypes.find(([name]) => name === type)?.[1] + const kind = spelledKinds?.get(attribute) + if (spelledKinds === undefined) found.push(`${gap}: the gaps list names it, the tables spell no ${type} type`) + else if (kind === undefined) found.push(`${gap}: the gaps list names it, the schema holds nothing`) + else found.push(`${gap}: the gaps list names it, the tables spell ${kind}`) + } assert.deepEqual(found, []) }) @@ -91,7 +98,7 @@ function schemaTypes(): Map { const where = `${file} ${name}` for (const properties of alternatives(schemaObject(definition, where), definitions, where)) { const attributes = (properties.get('attrs') ?? []).flatMap((attrs) => alternatives(attrs, definitions, `${where} attrs`)).flatMap((alternative) => [...alternative]) - for (const type of (properties.get('type') ?? []).flatMap(enumStrings)) { + for (const type of (properties.get('type') ?? []).flatMap((schema) => enumStrings(schema, `${where} type`))) { const kinds = held.get(type) ?? new Map>() held.set(type, kinds) for (const [attribute, schemas] of attributes) { @@ -107,14 +114,21 @@ function schemaTypes(): Map { } function alternatives(schema: SchemaObject, definitions: SchemaObject, where: string): Properties[] { - const own = Object.entries(schemaObject(schema['properties'] ?? {}, `${where} properties`)) - let found: Properties[] = [new Map(own.map(([name, property]): [string, SchemaObject[]] => [name, [schemaObject(property, `${where} ${name}`)]]))] - if (schema['$ref'] !== undefined) found = intersect(found, alternatives(referenced(schema['$ref'], definitions, where), definitions, `${where} $ref`)) + const own = Object.entries(schemaObject(readSchema(schema, where)['properties'] ?? {}, `${where} properties`)) + let found: Properties[] = [new Map(own.map(([name, property]): [string, SchemaObject[]] => [name, [readSchema(schemaObject(property, `${where} ${name}`), `${where} ${name}`)]]))] + if (schema['$ref'] !== undefined) found = intersect(found, alternatives(referenced(schema['$ref'], definitions, where), definitions, `${where} ${String(schema['$ref'])}`)) for (const branch of branches(schema['allOf'], `${where} allOf`)) found = intersect(found, alternatives(branch, definitions, `${where} allOf`)) if (schema['anyOf'] !== undefined) found = intersect(found, branches(schema['anyOf'], `${where} anyOf`).flatMap((branch) => alternatives(branch, definitions, `${where} anyOf`))) return found } +function readSchema(schema: SchemaObject, where: string): SchemaObject { + const unread = Object.keys(schema).find((keyword) => !readKeywords.includes(keyword)) + if (unread !== undefined) return assert.fail(`${where}: the schema holds the keyword ${unread}, which the gate does not read`) + const extra = schema['additionalProperties'] + return extra === undefined || typeof extra === 'boolean' ? schema : assert.fail(`${where}: additionalProperties holds a schema, which the gate does not read`) +} + function intersect(left: readonly Properties[], right: readonly Properties[]): Properties[] { return left.flatMap((own) => right.map((other) => { @@ -135,9 +149,9 @@ function branches(value: unknown, where: string): SchemaObject[] { return Array.isArray(value) ? value.map((branch, index) => schemaObject(branch, `${where} ${index}`)) : assert.fail(`${where} is no array of schemas`) } -function enumStrings(schema: SchemaObject): string[] { +function enumStrings(schema: SchemaObject, where: string): string[] { const values = schema['enum'] - return Array.isArray(values) ? values.filter((value: unknown): value is string => typeof value === 'string') : [] + return Array.isArray(values) ? values.filter((value: unknown): value is string => typeof value === 'string') : assert.fail(`${where}: the type property holds no enum naming the type`) } function propertyKinds(property: SchemaObject, where: string): AttributeKind[] {