dogsbay 0.2.0-beta.46 → 0.2.0-beta.48

package/dist/audit/rules/structure/index.js

@@ -16,6 +16,7 @@ import { internalLinks } from "./internal-links.js";
 import { localeCoherence } from "./locale-coherence.js";
 import { namespaceCoherence } from "./namespace-coherence.js";
 import { navTargetExists } from "./nav-target-exists.js";
+import { unresolvedDirectives } from "./unresolved-directives.js";
 import { versionCoherence } from "./version-coherence.js";
 let registered = false;
 /**
@@ -32,6 +33,7 @@ export function registerStructureRules() {
     registerRule(navTargetExists);
     registerRule(internalLinks);
     registerRule(assetRefs);
+    registerRule(unresolvedDirectives);
 }
 /**
  * Test-only: reset the "registered" flag so unit tests can

package/dist/audit/rules/structure/unresolved-directives.js

@@ -0,0 +1,108 @@
+/**
+ * Strict variable form: `{{ name }}`, `{{ obj.field }}`,
+ * `{{ name|filter }}`, `{{ name | filter }}`. Identifier-then-optional-filter
+ * shape so a stray `{{` in legitimate prose (e.g. discussing
+ * mathematical notation) doesn't false-positive.
+ */
+const VAR_RE = /\{\{\s*([a-zA-Z_][\w.-]*)\s*(?:\|[^}]+)?\s*\}\}/g;
+/**
+ * Strict block form: `{% if name %}` / `{% endif %}` / `{% set ... %}` /
+ * `{% include "..." %}` / `{%- ... -%}` (whitespace control variants).
+ * Anchored to a known keyword so a generic `{% ... %}` we don't
+ * recognise isn't flagged (Minja's grammar is a subset of Jinja —
+ * surfacing only the patterns the engine actually emits keeps the
+ * rule focused on what the preprocessor would have resolved).
+ */
+const BLOCK_RE = /\{%-?\s*(if|elif|else|endif|for|endfor|set|include|raw|endraw|leveloffset|switch|case|endswitch|default)\b[^%]*%\}/g;
+/**
+ * Walk a TreeNode tree, accumulating directive hits from text
+ * content. Skips code-flavoured nodes so documentation of Jinja
+ * syntax doesn't false-positive.
+ */
+function findHits(nodes, out) {
+    for (const node of nodes) {
+        if (node.type === "code")
+            continue;
+        if (node.inline)
+            findInlineHits(node.inline, out);
+        if (typeof node.html === "string")
+            scanText(node.html, out);
+        if (typeof node.props?.title === "string")
+            scanText(node.props.title, out);
+        if (node.children)
+            findHits(node.children, out);
+    }
+}
+function findInlineHits(nodes, out) {
+    for (const node of nodes) {
+        if (node.type === "code")
+            continue;
+        if (node.type === "text") {
+            scanText(node.text, out);
+        }
+        else if (node.type === "link" && node.children) {
+            findInlineHits(node.children, out);
+        }
+        else if (node.type === "highlight" && node.children) {
+            findInlineHits(node.children, out);
+        }
+        else if (node.type === "html-inline" && typeof node.html === "string") {
+            scanText(node.html, out);
+        }
+    }
+}
+function scanText(text, out) {
+    let m;
+    VAR_RE.lastIndex = 0;
+    while ((m = VAR_RE.exec(text)) !== null) {
+        out.push({ match: m[0], kind: "variable" });
+    }
+    BLOCK_RE.lastIndex = 0;
+    while ((m = BLOCK_RE.exec(text)) !== null) {
+        out.push({ match: m[0], kind: "block" });
+    }
+}
+/**
+ * Build the three-fix message for one hit. Keep it dense but
+ * actionable — the audit text formatter renders one line per
+ * finding plus the message.
+ */
+function formatMessage(hit) {
+    const kindLabel = hit.kind === "variable"
+        ? "variable reference"
+        : "conditional / block directive";
+    return (`Unresolved Minja ${kindLabel} \`${hit.match}\` survived to the rendered ` +
+        `page. Fix one of: ` +
+        `(1) add the missing value to the \`attributes:\` block in ` +
+        `\`dogsbay.config.yml\`; ` +
+        `(2) pass \`dogsbay site build --attribute name=value\` for per-build ` +
+        `overrides (CI secrets, deploy targets); ` +
+        `(3) if the literal is intentional (e.g. the page documents Jinja ` +
+        `syntax), add \`preprocess: false\` to the page's frontmatter.`);
+}
+export const unresolvedDirectives = {
+    id: "structure/unresolved-directives",
+    category: "structure",
+    stage: "source",
+    severity: "warning",
+    description: "Flags surviving Minja `{{ var }}` / `{% if %}` directives in page content " +
+        "(the preprocessor couldn't resolve them and they're heading to the rendered HTML).",
+    run(rawCtx) {
+        const ctx = rawCtx;
+        if (!ctx.page)
+            return [];
+        if (ctx.page.frontmatter?.preprocess === false)
+            return [];
+        const hits = [];
+        findHits(ctx.page.tree, hits);
+        if (hits.length === 0)
+            return [];
+        return hits.map((hit) => ({
+            ruleId: "structure/unresolved-directives",
+            severity: "warning",
+            file: `${ctx.page.slug}.md`,
+            message: formatMessage(hit),
+            context: hit.match,
+        }));
+    },
+};