aontu 0.67.0 → 0.68.0

package/src/vet.ts

@@ -280,14 +280,14 @@ function orderKey(f: VetFinding, index: number): string {
 export function engineFinding(
   nil: any, ctx: any, path: string): VetFinding {
   if (null == nil) {
-    return {
+    return fromRegistry({
       code: UNSHAPED,
       class: codeClass(UNSHAPED),
       severity: 'error',
       path,
       message: 'The document does not evaluate.',
       sites: [],
-    }
+    }, { why: UNSHAPED })
   }
 
   materialise(nil, ctx)
@@ -423,14 +423,62 @@ function coverDataPaths(
 }
 
 
+// A spread or a key can carry a shape-preserving call or a reference,
+// and coverage wants the bag under it; the seen set settles a cycle.
+export function coverThrough(v: any, root: any): any {
+  let at = v
+  const seen = new Set<any>()
+  while (null != at && !seen.has(at)) {
+    if (true === at.isMap || true === at.isList) {
+      return at
+    }
+    seen.add(at)
+    if ((true === at.isCloseFunc || true === at.isTypeFunc) &&
+      Array.isArray(at.peg)) {
+      at = at.peg[0]
+      continue
+    }
+    // A relative reference reads from where it was WRITTEN, not where
+    // the template lands, so the engine's own resolution is the rule.
+    if (true === at.isRef) {
+      at = coverRefTarget(root, at.plainRefPath())
+      continue
+    }
+    if (true === at.isRecurse) {
+      at = coverRefTarget(root, at.target)
+      continue
+    }
+    return undefined
+  }
+  return undefined
+}
+
+
+// A reference descends a list by the segment AS WRITTEN: `$.Defs.0`.
+function coverRefTarget(root: any, segs: string[] | undefined): any {
+  if (null == segs) {
+    return undefined
+  }
+  let at = root
+  for (const seg of segs) {
+    at = true === at?.isMap || true === at?.isList ? at.peg?.[seg] : undefined
+  }
+  return at
+}
+
+
 // Walk one data path down the schema, naming the declaration that
 // constrains it -- the exact key where the schema has one, else the
 // covering template. Undefined when the schema declares nothing there.
 function coverMatch(
-  anchor: any, segs: string[]): string | undefined {
+  anchor: any, segs: string[], root: any): string | undefined {
   let at: any = anchor
   let decl = ''
   for (const seg of segs) {
+    at = coverThrough(at, root)
+    if (null == at) {
+      return undefined
+    }
     const named = true === at.isMap && null != at.peg ? at.peg[seg]
       : true === at.isList && Array.isArray(at.peg) ? at.peg[Number(seg)]
         : undefined
@@ -470,7 +518,8 @@ function coverShallowest(paths: string[]): string[] {
 // The accounting itself: what the schema declared, what the data holds,
 // and which of each the other met.
 export function vetCoverage(
-  anchor: any, dataVal: any, coverageAt?: string): VetCoverage {
+  anchor: any, dataVal: any, coverageAt: string | undefined,
+  root: any): VetCoverage {
   const declarations = new Map<string, any>()
   coverDeclare(anchor, [], declarations)
 
@@ -499,7 +548,7 @@ export function vetCoverage(
       continue
     }
     const segs = path.replace(/^\$\.?/, '').split('.').filter((x) => '' !== x)
-    const decl = coverMatch(anchor, segs)
+    const decl = coverMatch(anchor, segs, root)
     if (leaf) {
       leaves++
     }
@@ -617,7 +666,7 @@ export function vet(
     // the same paths minus whatever an include would have added.
     const measured = 0 === coverCtx.err.length && true !== settledData?.isNil
       ? settledData : dataVal
-    coverage = vetCoverage(anchor, measured, options.coverageAt)
+    coverage = vetCoverage(anchor, measured, options.coverageAt, schemaVal)
   }
 
   const lintFindings: VetFinding[] = []