@agentshouse/mdmodel 0.1.0-c64451b2127b4 → 0.1.0-c669bdbad8a03

package/dist/validate.js

@@ -1,7 +1,7 @@
 import { ATTACHMENT, BUILT_IN_TYPE, readSchema } from './definition.js';
 import { parse } from './document.js';
 import { hrefOccurrences, linkInventory } from './links.js';
-import { classifyHref } from './paths.js';
+import { classifyHref, roomTarget } from './paths.js';
 import { references } from './references.js';
 import { refusal } from './refuse.js';
 import { fitsItem, frontmatterRefusal } from './schema.js';
@@ -18,25 +18,42 @@ function instanceType(document) {
         return null;
     return raw;
 }
-function reaches(file, href, to, types, binaryTargets) {
-    const resolved = classifyHref(file, href);
-    if (resolved.kind !== 'path')
+function reaches(reference, typeOf, binary) {
+    if (reference.target === null)
         return false;
-    if (to.includes(ATTACHMENT))
+    if (reference.to.includes(ATTACHMENT))
         return true;
-    if (binaryTargets.has(resolved.path))
+    if (binary(reference.target))
+        return false;
+    const held = typeOf(reference.target);
+    return held === undefined || reference.to.includes(held);
+}
+function missing(reference, typeOf, binary) {
+    if (reference.to.includes(ATTACHMENT) || reference.target === null)
         return false;
-    const held = types.get(resolved.path);
-    return held === undefined || to.includes(held);
+    return typeOf(reference.target) === undefined && !binary(reference.target);
+}
+export function resolves(reference, typeOf, binary) {
+    return reaches(reference, typeOf, binary) && !missing(reference, typeOf, binary);
+}
+function usesIn(content) {
+    let held;
+    return () => {
+        if (held !== undefined)
+            return held;
+        const bodyStart = bodyStartOf(content);
+        held = linkInventory(content.slice(bodyStart)).uses.map((use) => ({
+            ...use,
+            start: bodyStart + use.start,
+            end: bodyStart + use.end,
+        }));
+        return held;
+    };
 }
-function itemHrefs(content, items) {
-    const bodyStart = bodyStartOf(content);
-    const { uses } = linkInventory(content.slice(bodyStart));
+function itemHrefs(content, items, uses) {
     const hrefs = [];
     for (const item of items) {
-        const link = uses.find((use) => bodyStart + use.start === item.start &&
-            bodyStart + use.end === item.end &&
-            content[item.start] === '[');
+        const link = uses().find((use) => use.start === item.start && use.end === item.end && content[item.start] === '[');
         if (link === undefined)
             return null;
         hrefs.push(link.destination.href);
@@ -53,10 +70,142 @@ export function verify(schema) {
         ...(read.location === undefined ? {} : { location: read.location }),
     };
 }
-export function validate(library, context = { binaryTargets: [] }, model = { types: {} }) {
+function structure(file, content, document, definition) {
+    if (definition === undefined)
+        return { refusal: refuse(file, 'unknown-type', { location: '/type' }) };
+    const fieldFailure = frontmatterRefusal(definition, document.fields);
+    if (fieldFailure !== undefined) {
+        return { refusal: refuse(file, fieldFailure.rule, { location: fieldFailure.location }) };
+    }
+    const spans = headingSpans(content, bodyStartOf(content));
+    const uses = usesIn(content);
+    const sections = [];
+    for (const [name, spec] of Object.entries(definition.sections)) {
+        const occurrences = spans.filter((one) => one.name === name);
+        if (occurrences.length === 0 && spec.required)
+            return { refusal: refuse(file, 'required-section', { location: name }) };
+        if (spec.kind !== 'list')
+            continue;
+        for (const span of occurrences) {
+            const items = listItems(content, span.bodyStart, span.bodyEnd);
+            if (items === null ||
+                items.some((item) => !fitsItem(definition, name, content.slice(item.start, item.end))))
+                return { refusal: refuse(file, 'structured-section', { location: name }) };
+            if (spec.items.reference === undefined)
+                continue;
+            const hrefs = itemHrefs(content, items, uses);
+            if (hrefs === null)
+                return { refusal: refuse(file, 'structured-section', { location: name }) };
+            sections.push({
+                section: name,
+                to: spec.items.reference,
+                crossRoom: spec.items.crossRoom === true,
+                hrefs,
+            });
+        }
+    }
+    return { sections };
+}
+function linked(file, content) {
+    return hrefOccurrences(bodyAfterFrontmatter(content)).every((occurrence) => classifyHref(file, occurrence.href).kind !== 'invalid');
+}
+function reached(file, href, to) {
+    const resolved = classifyHref(file, href);
+    return { target: resolved.kind === 'path' ? resolved.path : null, to };
+}
+function crossing(file, href, crossRoom) {
+    return crossRoom === true && classifyHref(file, href).kind === 'room';
+}
+function definitionOf(document, model) {
+    const kind = instanceType(document);
+    return kind === null || !Object.hasOwn(model.types, kind) ? undefined : model.types[kind];
+}
+export function checkDocument(file, content, model) {
+    const parsed = parse(content, file);
+    if (!parsed.ok)
+        return { ok: false };
+    const document = parsed.document;
+    const type = document.type ?? BUILT_IN_TYPE;
+    if (instanceType(document) === BUILT_IN_TYPE)
+        return { ok: true, type, typed: false, references: [] };
+    const definition = definitionOf(document, model);
+    const read = structure(file, content, document, definition);
+    if ('refusal' in read || definition === undefined || !linked(file, content))
+        return { ok: false };
+    return {
+        ok: true,
+        type,
+        typed: true,
+        references: [
+            ...references(document, definition).flatMap(({ value, to, crossRoom }) => crossing(file, value, crossRoom) ? [] : [reached(file, value, to)]),
+            ...read.sections.flatMap(({ to, crossRoom, hrefs }) => hrefs.flatMap((href) => (crossing(file, href, crossRoom) ? [] : [reached(file, href, to)]))),
+        ],
+    };
+}
+export function sectionReferences(file, content, definition) {
+    const referring = (name) => {
+        const spec = Object.hasOwn(definition.sections, name) ? definition.sections[name] : undefined;
+        return spec?.kind === 'list' && spec.items.reference !== undefined ? spec.items : undefined;
+    };
+    if (!Object.keys(definition.sections).some((name) => referring(name) !== undefined))
+        return [];
+    const uses = usesIn(content);
+    const found = [];
+    for (const span of headingSpans(content, bodyStartOf(content))) {
+        const items = referring(span.name);
+        if (items === undefined)
+            continue;
+        const listed = listItems(content, span.bodyStart, span.bodyEnd);
+        const hrefs = listed === null ? null : itemHrefs(content, listed, uses);
+        for (const href of hrefs ?? [])
+            if (!crossing(file, href, items.crossRoom))
+                found.push(reached(file, href, items.reference));
+    }
+    return found;
+}
+export function bodyRoomLinks(body) {
+    const found = [];
+    for (const href of new Set(hrefOccurrences(body).map((occurrence) => occurrence.href))) {
+        const room = roomTarget(href);
+        if (room !== null)
+            found.push({ kind: 'link', href, ...room });
+    }
+    return found;
+}
+export function roomReferences(file, content, definition) {
+    const found = bodyRoomLinks(bodyAfterFrontmatter(content));
+    if (definition === undefined)
+        return found;
+    const parsed = parse(content, file);
+    if (!parsed.ok)
+        return found;
+    for (const { pointer, value, to, crossRoom } of references(parsed.document, definition)) {
+        const room = crossRoom === true ? roomTarget(value) : null;
+        if (room !== null)
+            found.push({ kind: 'field', pointer, value, to, ...room });
+    }
+    const uses = usesIn(content);
+    for (const span of headingSpans(content, bodyStartOf(content))) {
+        const spec = Object.hasOwn(definition.sections, span.name)
+            ? definition.sections[span.name]
+            : undefined;
+        if (spec?.kind !== 'list' || spec.items.reference === undefined || !spec.items.crossRoom)
+            continue;
+        const listed = listItems(content, span.bodyStart, span.bodyEnd);
+        for (const href of (listed === null ? null : itemHrefs(content, listed, uses)) ?? []) {
+            const room = roomTarget(href);
+            if (room !== null)
+                found.push({ kind: 'item', section: span.name, href, to: spec.items.reference, ...room });
+        }
+    }
+    return found;
+}
+export function* validating(library, context = { binaryTargets: [] }, model = { types: {} }) {
     const binaryTargets = new Set(context.binaryTargets);
+    const binary = (path) => binaryTargets.has(path);
     const files = Object.keys(library).sort();
     const types = new Map();
+    const typeOf = (path) => types.get(path);
     const documents = new Map();
     for (const file of files) {
         if (binaryTargets.has(file))
@@ -67,100 +216,56 @@ export function validate(library, context = { binaryTargets: [] }, model = { typ
         types.set(file, parsed.document.type ?? BUILT_IN_TYPE);
         if (instanceType(parsed.document) !== BUILT_IN_TYPE)
             documents.set(file, parsed.document);
+        yield file;
     }
-    const definitions = new Map(Object.entries(model.types));
     const sectionReferences = new Map();
     for (const [file, document] of documents) {
-        const kind = instanceType(document);
-        if (kind === BUILT_IN_TYPE)
-            continue;
-        const definition = kind === null ? undefined : definitions.get(kind);
-        if (definition === undefined)
-            return refuse(file, 'unknown-type', { location: '/type' });
-        const fieldFailure = frontmatterRefusal(definition, document.fields);
-        if (fieldFailure !== undefined) {
-            return refuse(file, fieldFailure.rule, { location: fieldFailure.location });
-        }
-        const content = library[file];
-        const spans = headingSpans(content, bodyStartOf(content));
-        const references = [];
-        for (const [name, spec] of Object.entries(definition.sections)) {
-            const occurrences = spans.filter((one) => one.name === name);
-            if (occurrences.length === 0 && spec.required)
-                return refuse(file, 'required-section', { location: name });
-            if (spec.kind !== 'list')
-                continue;
-            for (const span of occurrences) {
-                const items = listItems(content, span.bodyStart, span.bodyEnd);
-                if (items === null ||
-                    items.some((item) => !fitsItem(definition, name, content.slice(item.start, item.end))))
-                    return refuse(file, 'structured-section', { location: name });
-                if (spec.items.reference === undefined)
-                    continue;
-                const hrefs = itemHrefs(content, items);
-                if (hrefs === null)
-                    return refuse(file, 'structured-section', { location: name });
-                references.push({ section: name, to: spec.items.reference, hrefs });
-            }
-        }
-        sectionReferences.set(file, references);
+        const read = structure(file, library[file], document, definitionOf(document, model));
+        if ('refusal' in read)
+            return read.refusal;
+        sectionReferences.set(file, read.sections);
+        yield file;
     }
+    let least;
     for (const [file, document] of documents) {
-        const kind = instanceType(document);
-        if (kind === null || kind === BUILT_IN_TYPE)
-            continue;
-        const definition = definitions.get(kind);
-        if (definition === undefined)
-            continue;
-        for (const { pointer, to, value } of references(document, definition)) {
-            if (!reaches(file, value, to, types, binaryTargets))
-                return refuse(file, 'unresolved-reference', { location: pointer });
-        }
-        const body = bodyAfterFrontmatter(library[file]);
-        for (const occurrence of hrefOccurrences(body)) {
-            const resolved = classifyHref(file, occurrence.href);
-            if (resolved.kind === 'invalid')
-                return refuse(file, 'unresolved-link');
+        const definition = definitionOf(document, model);
+        const fields = references(document, definition).flatMap(({ pointer, value, to, crossRoom }) => crossing(file, value, crossRoom)
+            ? []
+            : [{ reference: reached(file, value, to), location: pointer }]);
+        for (const { reference, location } of fields) {
+            if (!reaches(reference, typeOf, binary))
+                return refuse(file, 'unresolved-reference', { location });
         }
-        for (const { section, to, hrefs } of sectionReferences.get(file)) {
-            for (const href of hrefs) {
-                if (!reaches(file, href, to, types, binaryTargets))
-                    return refuse(file, 'unresolved-reference', { location: section });
-            }
+        if (!linked(file, library[file]))
+            return refuse(file, 'unresolved-link');
+        const sections = sectionReferences
+            .get(file)
+            .flatMap(({ section, to, crossRoom, hrefs }) => hrefs.flatMap((href) => crossing(file, href, crossRoom)
+            ? []
+            : [{ reference: reached(file, href, to), location: section }]));
+        for (const { reference, location } of sections) {
+            if (!reaches(reference, typeOf, binary))
+                return refuse(file, 'unresolved-reference', { location });
         }
-    }
-    const missing = new Map();
-    for (const [file, document] of documents) {
-        const kind = instanceType(document);
-        if (kind === null || kind === BUILT_IN_TYPE)
-            continue;
-        const definition = definitions.get(kind);
-        if (definition === undefined)
-            continue;
-        const named = [
-            ...references(document, definition),
-            ...sectionReferences
-                .get(file)
-                .flatMap(({ to, hrefs }) => hrefs.map((value) => ({ value, to }))),
-        ];
-        for (const { value, to } of named) {
-            if (to.includes(ATTACHMENT))
-                continue;
-            const resolved = classifyHref(file, value);
-            if (resolved.kind !== 'path')
-                continue;
-            if (types.has(resolved.path) || binaryTargets.has(resolved.path))
+        for (const { reference } of [...fields, ...sections]) {
+            if (!missing(reference, typeOf, binary))
                 continue;
-            const referrers = missing.get(resolved.path) ?? [];
-            referrers.push(file);
-            missing.set(resolved.path, referrers);
+            const path = reference.target;
+            if (least === undefined || path < least.path)
+                least = { path, referrers: [] };
+            if (path === least.path && least.referrers.at(-1) !== file)
+                least.referrers.push(file);
         }
+        yield file;
     }
-    const missingPaths = [...missing.keys()].sort();
-    if (missingPaths.length > 0) {
-        const path = missingPaths[0];
-        const referrers = [...new Set(missing.get(path) ?? [])].sort();
-        return refuse(path, 'referenced-missing-file', { referrers });
-    }
+    if (least !== undefined)
+        return refuse(least.path, 'referenced-missing-file', { referrers: least.referrers });
     return { verdict: 'accept' };
 }
+export function validate(library, context = { binaryTargets: [] }, model = { types: {} }) {
+    const steps = validating(library, context, model);
+    let step = steps.next();
+    while (step.done !== true)
+        step = steps.next();
+    return step.value;
+}

package/fixtures/cases/cross-room-link/context.json

@@ -0,0 +1 @@
+{ "binaryTargets": [] }

package/fixtures/cases/cross-room-link/expected.json

@@ -0,0 +1 @@
+{ "verdict": "accept" }

package/fixtures/cases/cross-room-link/library/clients/acme.md

@@ -0,0 +1,6 @@
+---
+type: client
+name: Acme
+---
+
+Paid by [the March invoice](/rooms/finance/invoices/march.md#total).

package/fixtures/cases/cross-room-link/schema.yaml

@@ -0,0 +1,3 @@
+client:
+  properties:
+    name: { type: string }

package/fixtures/cases/cross-room-reference/context.json

@@ -0,0 +1 @@
+{ "binaryTargets": [] }

package/fixtures/cases/cross-room-reference/expected.json

@@ -0,0 +1 @@
+{ "verdict": "accept" }

package/fixtures/cases/cross-room-reference/library/clients/acme.md

@@ -0,0 +1,9 @@
+---
+type: client
+name: Acme
+finance: /rooms/finance/invoices/acme.md
+---
+
+## Invoices
+
+- [March](/rooms/finance/invoices/march.md)

package/fixtures/cases/cross-room-reference/schema.yaml

@@ -0,0 +1,9 @@
+client:
+  properties:
+    name: { type: string }
+    finance: { type: string, reference: invoice, cross_room: true }
+  sections:
+    Invoices: { kind: list, items: { type: string, reference: invoice, cross_room: true } }
+invoice:
+  properties:
+    name: { type: string }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/mdmodel",
-  "version": "0.1.0-c64451b2127b4",
+  "version": "0.1.0-c669bdbad8a03",
   "description": "MD Type language, parser, validator, structured change application, Markdown syntax profile, and conformance fixtures",
   "license": "MIT",
   "type": "module",